Contents
Download Benchmark Apps
A Settings, Security option may need changing to allow installation of non-Market applications
|
Java Whetstone.apk
First standard benchmark
|
|
|
|
NativeWhetstone.apk
Faster compiled version
|
|
|
Linpackv7.apk
For newer, faster vfpv3 H/W.
|
|
|
|
Linpackv5.apk
Using older H/W instructions
|
|
|
LinpackSP.apk
Single Precision for vfpv3
|
|
|
|
LinpackJava.apk
All Java version
|
|
|
Dhrystone2.apk
First integer benchmark
|
|
|
|
Dhry2Nopt.apk
Non-optimised compilation
|
|
|
LivermoreLoops.apk
1st supercomputer benchmark
|
|
|
|
MemSpeed.apk
Cache/RAM calculating
|
|
|
BusSpeed.apk
Cache/RAM/Bus max speeds
|
|
|
|
BusSpeedv7.apk
For Android 4 and v7 HW
|
|
|
RandMem.apk
Cache/RAM random access
|
|
|
|
CPU_MHz.apk
Measure CPU MHz
|
|
|
|
DriveSpeed.apk
SD card/internal drive tests
|
|
|
|
DriveSpd2.apk
Drive tests, user defined path
|
|
All have option to save results via Email
WARNING - Most of the benchmarks provide two libraries. Early versions of Android 4, Ice Cream Sandwich, can sometimes fail to select the one to use faster hardware instructions, resulting in extremely slow performance.
See Here
and Here
NOTE - except for later MP versions, these benchmarks only use one core of multi-core processors. Then for maximum and consistent performance, some units might need setting of a CPU Mode (example ICS Settings, Developer Options, CPU Mode, Change Normal to Performance).
To Start
General
Roy Longbottom’s PC Benchmark Collection comprises numerous FREE benchmarks and reliability testing programs, for processors, caches, memory, buses, disks, flash drives, graphics, local area networks and Internet. Original ones run under DOS and later ones under all varieties of Windows. Most have also been converted to run under Linux. Android is the natural progression from the latter, but we will have to wait to see what is possible.
Initial development with Java was via Eclipse Integrated Development Environment for Java
from here and using Android Software Development Kit
from here.
In this case, programs were developed on a PC via 64-Bit Windows 7. The development environment provides a range Android version emulators, testable on what are displayed as real phones and tablets.
With Java programs being compiled at run time, they might not run very fast, compared with a pre-compiled version, using high optimisation levels. The latter for Android can be generated from C/C++ code using Native Development Kit, downloadable
from here.
To use this via Windows, a Linux-like environment, provided by
Cygwin
is required. In my case, this would not install properly via 64-Bit Windows 7. So, NDK benchmarks were developed on a PC that runs Linux Ubuntu.
Eclipse projects including source code and other required files, for all benchmarks, are available in
www.roylongbottom.org.uk/Android Benchmarks.zip.
As indicated above, early versions of Android 4, Ice Cream Sandwich, can sometimes fail to select library to use fast vfpv3 hardware, resulting in extremely slow performance, but a way to avoid it has been found.
|
|
Standard Layout
With right/left scroll for all details. Save results via Email.
Versions 1.1 January 2013
Coloured display instead of black and white,
background image,
wider format for HD displays.
|
Initial results suggested that some CPUs were not running at the specified MHz. This can be confirmed with a new program. See
Measure CPU MHz.
Tablet T11 has a Cortex-A15 CPU, rated at 2000 MHz, but only runs at 1700 MHz. This was further confirmed by the following text file that shows milliseconds used at different frequencies. Although 2 GHz appears to be used occasionally, the count did not increase after running several benchmarks.
/sys/devices/system/cpu/cpu0/cpufreq/stats/time_in_state
To Start
Java Whetstone Benchmark
The first of this series is a Java version of the Whetstone Benchmark. The original, written in Fortran, was the first general purpose benchmark that set industry standards of computer performance. It was released in 1972, based on research by Brian Wichmann, and produced by Harold Curnow. Later updates became my responsibility. The three of us were UK Government employees. Speed was measured in terms of Million Whetstone Instructions Per Second (MWIPS). Later, in order to identify compiler over-optimisation, speeds of individual tests were shown as MOPS or MFLOPS - Millions of Operations or Floating Point Operations Per Second. In this version, test functions are for a minimum of one second, milliseconds for the originally defined pass count being used for MWIPS calculations, as 10,000 / Total milliseconds.
This compilation celebrates the 40th anniversary of the benchmark. The .apk application file can be downloaded from
www.roylongbottom.org.uk/Java Whetstone.apk.
See also
Whetstone Benchmark History and Results
for performance of computers from the 1960’s to modern times, and
Whetstone Benchmark Results on PCs,
these including speeds using Java code via Windows and Linux.
To Start
Java Whetstone Operation
Installation Click on the link for the apk file and download for the icon to appear in a Download list or in a Download folder on an SD card. In Settings, Applications, tick allow installation of non-Market applications. Tap the app icon and buttons to install and run it.
On loading the app, three buttons are provided. Run executes the benchmark and this normally takes between 10 and 20 seconds. The results shown below, up to Total Elapsed Time, are then displayed. The Info button produces three more buttons to provide a summary of the benchmark, a link to this HTML document and another to the History HTML pages. If the benchmark has been run, Save Emails the full results shown below to
results@roylongbottom.org.uk
(assuming that local Email has been set up).
Note that the Email system might not display the results with a monospaced font, but the space characters appear to be there, allowing copying/pasting to a document with the right font (like Courier New 10).
Screen pixel dimensions and Android Build Version are obtained using Android Java functions with other information read from files /proc/cpuinfo and /proc/version.
On tapping the Save button, an Edit Box is provided for manual input of other details of the system under test (Device details below).
Android Java Whetstone Benchmark 17-Jan-2012 14.22
Test MFLOPS MOPS millisecs Results
N1 float 3.18 6.040 -1.124750137
N2 float 3.91 34.340 -1.131330490
N3 if 4.29 24.140 1.000000000
N4 fixpt 9.59 32.840 12.000000000
N5 cos 0.42 196.100 0.499110103
N6 float 2.90 186.000 0.999999821
N7 equal 3.28 56.300 3.000000000
N8 exp 0.22 171.100 0.751108646
MWIPS 14.15 706.860
Total Elapsed Time 14.6 seconds
System Information
Screen pixels w x h 600 x 1024
Android Build Version 2.2
Processor : ARM926EJ-S rev 5 (v5l)
BogoMIPS : 797.97
Features : swp half thumb fastmult edsp java
CPU implementer : 0x41
CPU architecture: 5TEJ
CPU variant : 0x0
CPU part : 0x926
CPU revision : 5
Hardware : WMT
Revision : 0000
Serial : 0000000000000000
Linux version 2.6.32.9-default (jodyfu@szmce13)
(gcc version 4.5.1 (Sourcery G++ Lite 2010.09-50)
) #100 Wed Sep 21 08:25:24 HKT 2011
Device TTFone M013S 10.1 inch tablet, 300-800 MHz VIA 8650
|
To Start
Java Whetstone Results
The first measurements obtained were via emulators running on a 3 GHz quad core Phenom, the benchmark only using one core, of course. They suggest a slightly slower performance using a screen with a higher pixel density and much better performance with a later Android version and/or a more modern CPU.
Based on comparisons with CPU MHz, v7-A8 CPUs are faster than the ARM 926EJ CPU, due to VFPv3 enhanced floating point hardware, and in turn, v7-A9s are even faster. Performance of P8, with the Qualcomm MSM8960 CPU, is superior to these ARM devices. Some of the v7-A9 resulrs are not proportional to CPU MHz, where calculations suggest that that 1300 MHz T7 and 1500 MHz T4 are running at 1200 MHz.
This was confirmed later, using a new program. See Measure CPU MHz.
August 2013 - Cortex-A15 based tablet T11 (really running at 1700 MHz) has the fastest speeds, at this time. On a per MHz basis, it outperforms Cortex-A9 by 30% to 40%, except on the mathematical function tests (headed COS and EXP) where performance is similar.
System ARM MHz Android MWIPS ---- MFLOPS ---- ---------- MOPS ------------
See CPU Build 1 2 3 COS EXP FIXPT IF EQUAL
T1 926EJ 800 2.2 14.2 3.2 3.9 2.9 0.4 0.2 9.6 4.3 3.3
T2 v7-A9 800 2.3.4 224.0 40.8 62.7 35.4 11.2 4.9 139.5 53.1 24.4
T3 v7-A9 1000 3.2 286.5 51.8 85.2 63.6 13.1 5.3 176.1 68.6 35.0
T4 v7-A9 1500a 4.0.3 347.6 65.7 97.7 60.3 16.2 6.3 211.7 72.7 44.0
T7 v7-A9 1300a 4.1.2 347.7 65.8 103.3 61.5 15.9 5.7 214.0 102.9 44.5
T11 v7-A15 2000b 4.2.2 533.9 131.4 209.4 102.5 20.4 6.7 475.8 174.8 105.7
T13 v7-A9 1400 4.1.2 346.2 51.2 85.1 65.7 14.9 6.3 175.9 65.7 48.2
P1 v7-A8 600 2.3.5 83.3 11.3 18.2 13.5 2.9 1.6 55.2 40.6 17.8
P2 v7-A8 1000 2.2 137.9 15.9 31.9 22.6 4.7 2.6 91.6 68.6 29.7
P9 v7-A8 1000 2.3.5 96.7 15.7 21.2 14.2 2.8 2.3 85.1 58.2 26.7
P3 v7-A9 1000 2.3.6 286.7 53.7 84.7 46.7 14.5 5.4 183.0 69.7 33.2
P11 v7-A9 1400 4.0.4 399.6 76.9 122.3 69.5 17.8 6.8 248.6 121.0 50.3
P8 QU-S4 1500 4.0.3 487.1 60.0 124.4 80.9 16.1 11.6 411.2 139.3 71.8
Measured MHz a=1200, b=1700
EP1 926EJ Emul 2.2 12.7 2.6 3.9 2.2 0.4 0.2 8.3 3.1 3.0
ET1 926EJ Emul 2.2 11.1 2.3 3.4 2.0 0.3 0.2 7.1 2.7 2.6
ET2 v7-A8 Emul 4.03 38.8 8.7 11.6 10.0 1.0 0.6 38.3 11.1 6.7
BS1 EmulPh 3000 2.3.4 314.3 47.1 69.6 43.5 23.9 13.8 90.0 39.4 46.2
Atom 1666 Linux 621 368 272 175 13.3 10.9 400 143 145
Atom 1666 And x86 91 15 23 12 6.5 3.3 29 11 15
Core2 2400 Linux 1925 812 759 459 49 27 1700 800 450
Core2 2400 And x86 356 45 122 52 20 10 153 46 47
System - T = Tablet, P = Phone, E = Emulator, QU = Qualcomm CPU
|
The last two sets of results are for the same Java code running on Intel CPUs under Linux and via Android x86.
These use different JIT compilers, voiding comparisons with the other Android results.
To Start
Java Numeric Results
Both emulated and real numeric results using ARMv7 are different from ARM926EJ for some floating point calculations. This is not unusual for different compilers or types of processor and is due to variations in instruction sequences or hardware rounding arrangements. It looks as though these two processors are not logically identical or program optimisation procesures are different.
ARMv7 P3 has enhanced architecture that probably changes the calculated results of the lasts test.
Results from Native Code versions are also provided.
Test ARM926EJ-S P1 ARMv7-A8 P2 ARMv7-A8 P3 ARMv7-A9
N1 float -1.124750137 -1.124750137 -1.124750137 -1.124750137
N2 float -1.131330490 -1.131330490 -1.131330490 -1.131330490
N3 if 1.000000000 1.000000000 1.000000000 1.000000000
N4 fixpt 12.000000000 12.000000000 12.000000000 12.000000000
N5 cos 0.499110103 0.499110132 0.499110132 0.499110132
N6 float 0.999999821 0.999999821 0.999999821 0.999999821
N7 equal 3.000000000 3.000000000 3.000000000 3.000000000
N8 exp 0.751108646 0.762195110 0.762195110 0.830691695
Native Code Versions
Fast FPU
ARM926EJ-S T2 ARMv7-A9 T2 ARMv7-A9
N5 cos 0.499109834 0.499109805 0.499109805
N8 exp 0.751108646 0.762195110 0.830691695
Android X86 Vesions
Intel Arom Intel Core 2
N5 cos 0.499110132 0.499110132
N8 exp 0.762195110 0.830691695
|
To Start
Native Whetstone Benchmark
The second Android benchmark uses the same Java front end code as #1, producing identical output format, but headed “Android Native Whetstone Benchmark”, with the C/C++ program using Java Native Interface and saved in a jni folder
(see zip file).
The C code does not produce any output (in this case?), except returning results to the Java program in a string. The code is compiled into a library, through an Android.mk file, in my case via a Terminal command ~/workspace/NativeWhetstone/jni$ ~/Eclipse/android-ndk-r7/ndk-build. The Java program includes a function to load the library.
Unexpectedly, the first compilation produced slower performance than a Java version - See T2 above and T2 @5 below. The solution was a new Application.mk file in the jni folder. This has a single directive (APP_ABI := armeabi armeabi-v7a) to build two libraries, one for older ARM5 CPUs and one for ARM7 with vfpv3 high performance floating point units, these being automatically selected at run time. As can be seen for T2 @7 below, a remarkable performance improvement was produced.
The .apk application file can be downloaded from
www.roylongbottom.org.uk/NativeWhetstone.apk.
See also
Whetstone Benchmark History and Results
for performance of computers from the 1960’s to modern times, and
Whetstone Benchmark Results on PCs,
these including speeds via Windows and Linux.
To Start
Native Whetstone Benchmark Results
For these tests, the emulator was run using one CPU of a 2.4 GHz Core 2 Duo. Again, this showed a performance gain emulating v7-A, with a further improvement using instructions for a vfpv3 FPU.
Unlike tablet T2, results on tablet T1, with the 926EJ CPU, show that the first compilation produces the same performance as the second,
The latter includes a library for vfpv3 instructions that are clearly not used.
As with Java Whetstone results, T4 and T7, v7-A9 CPUs, appear to be running slow at 1200 MHz, with T2, T6 and P11 running at the specified clock speed. This time, the Qualcomm CPU is not particularly faster.
Benchmarks run on T4, under Android 4, have a Development CPU Mode Setting of Performance, where continuously running at the maximum MHz could be expected. With a Normal Setting, performance can vary widely, as reflected below.
August 2013 - Compared with T7, the results show that T11, with the Cortex-A15, performs badly, on a per MHz basis, like 10% slower, although it obtains some of the best scores for ARM CPUs. The clock speed was confirmed, whilst running the benchmark, using
the program that measures CPU MHz.
Note: The programming code for the fixed point, if and equal tests produces identical results irrespective of the number of passes. A modern optimising compiler can opt to only run one pass and produce an indication of unachievable performance. The functions have been tweaked to, at least, execute some instructions in each pass. These tests use little time (see log above) with negligible effect on the overall rating but can be compared with other systems running the same .apk app. Do not compare these non-standard results with those from other compilations.
System ARM MHz Android MWIPS ------MFLOPS------- ------------MOPS--------------
See CPU Build 1 2 3 COS EXP FIXPT IF EQUAL
T1 @5 926EJ 800 2.2 31.2 10.2 10.2 11.4 0.6 0.3 38.8 278.4 219.4
T1 @7 926EJ 800 2.2 30.3 10.2 9.3 11.5 0.6 0.3 39.0 293.5 220.1
T2 @5 v7-A9 800 2.3.4 170.9 20.4 21.4 28.4 7.6 2.2 85.5 756.0 764.3
T2 @7 v7-A9 800 2.3.4 687.4 165.4 149.9 153.4 15.9 9.3 723.1 1082.1 725.3
T4 @7 v7-A9 1500a 4.0.3 1129.3 272.7 250.0 256.4 25.5 15.1 1197.5 1789.3 1190.7
T4 CPU Norm 1500 4.0.3 650.6 35.4 237.5 164.4 11.3 14.2 405.3 1468.9 1174.5
T4 CPU Norm 1500 4.0.3 203.1 46.2 90.7 53.8 3.9 2.7 221.6 199.1 472.3
T6 @7 v7-A9 1600 4.0.3 1514.6 350.3 330.9 339.2 35.0 20.5 1583.4 2355.5 1582.8
T7 @7 v7-A9 1300a 4.1.2 1115.0 271.3 250.7 256.4 25.8 14.6 1190.0 1797.0 1198.7
T11 @7 v7-A15 2000b 4.2.2 1477.7 363.9 220.6 307.5 39.7 18.0 1690.5 2527.9 1127.9
T13 @7 v7-A9 1400c 4.1.2 808.9 209.0 162.3 204.3 17.2 11.3 854.5 1273.2 906.6
T13 @7 v7-A9 1400 4.1.2 1180.6 303.5 283.5 264.3 28.8 14.4 1358.9 2998.2 1282.2
P8 @7 QU-S4 1500 4.0.3 1039.5 255.7 316.5 299.6 20.2 13.2 1503.6 1795.2 1504.2
P9 @7 v7-A8 1000 2.3.5 288.2 95.0 83.8 87.6 5.8 3.5 389.6 929.5 228.5
P11 @7 v7-A9 1400 4.0.4 1333.6 315.5 291.2 298.6 39.8 18.1 1394.7 2089.9 1395.5
Measured MHz a=1200, b=1700, c=power saving
EP1 @5 926EJ Emul 2.2 20.1 7.0 6.7 9.3 0.4 0.2 30.9 218.6 98.5
ET2 @5 v7-A8 Emul 4.03 43.7 7.2 7.0 9.3 1.1 0.6 30.8 225.1 100.9
ET2 @7 v7-A8 Emul 4.03 96.7 37.0 32.1 36.1 1.6 1.3 121.9 238.4 216.4
BS1 Emul Ph 3000 2.3.4 103.6 36.9 32.6 37.7 1.8 1.4 130.2 414.0 374.1
Atom 1666 Linux 769.0 330.0 333.0 282.0 17.1 7.2 968.0 1143.0 1149.0
Core 2 2400 Linux 2560.0 865.0 885.0 589.0 65.7 29.1 3851.0 5314.0 1078.0
System - T = Tablet, P = Phone, E = Emulator, @7 for vfpv3 FPU, QU = Qualcomm CPU
CPU Norm = ICS Settings, Developer Options, CPU Mode, Normal - other T4 = Performance
|
Results are also shown for Linux C compilations on two Intel processors.
In this case, the A9 CPU at 1500 MHz has a better overall score than the 1666 MHz Atom. This is due to the faster tests using such as Cos and Exp functions.
To Start
Linpack 100 Benchmark
The Linpack Benchmark was produced from the "LINPACK" package of linear algebra routines. It became the primary benchmark for scientific applications, particularly under Unix, from the mid 1980's, with a slant towards supercomputer performance. The original double precision C version, used here, operates on 100x100 matrices. Performance is governed by an inner loop in function daxpy() with a linked triad dy[i] = dy[i] + da * dx[i], and is measured in Millions of Floating Point Operations Per Second (MFLOPS).
Two versions use a Java front end, again providing Run, Info and Save buttons, with the main C code compiled by Android Native Development Kit.
A third comprises the same front end with Java code for Linpack calculations. They are Linpackv5.apk (LP5), using old, slow instructions, Linpackv7.apk (LPK) to use faster vfpv3 hardware
and LinpackJava.apk (LPJ) that depends on a suitable Runtime Environment. A fourth variety, LinpackSP.apk (LPsp) is also available, comprising the C version compiled to use single precision floating point.
The .apk application files can be downloaded from:
www.roylongbottom.org.uk/Linpackv5.apk and
www.roylongbottom.org.uk/LinpackJava.apk
www.roylongbottom.org.uk/Linpackv7.apk and
www.roylongbottom.org.uk/LinpackSP.apk
Further details of the Linpack benchmark, and results from Windows and Linux based PCs, can be found in
Linpack Results.htm.
The Java version has the same calibration calculations as my C program but the uses the
Code from Netlib
for the calculations, as C uses different function calling conventions.
Output results provide the same System Information as shown for the Whetstone Benchmark, preceded by MFLOPS speed and numeric results, examples being shown below.
In this case, calculations from the double precision versions produce the same numeric results, with differences using single precision functions. These are also identical to those from Microsoft Visual C under Windows and Linux using 64-Bit GCC on PCs, with other compilers used producing differences.
Android Linpack v5 Benchmark Android Java Linpack Benchmark
Speed 10.56 MFLOPS Speed 33.36 MFLOPS
norm. resid 1.7 norm. resid 1.7
resid 7.41628980e-14 resid 7.41628980e-14
machep 2.22044605e-16 machep 2.22044605e-16
x[0]-1 -1.49880108e-14 x[0]-1 -1.49880108e-14
x[n-1]-1 -1.89848137e-14 x[n-1]-1 -1.89848137e-14
Same
Android Linpack v7 Benchmark Android Linpack v7SP Benchmark
Speed 101.39 MFLOPS Speed 129.05 MFLOPS
norm. resid 1.7 norm. resid 1.6
resid 7.41628980e-14 resid 3.80277634e-05
machep 2.22044605e-16 machep 1.19209290e-07
x[0]-1 -1.49880108e-14 x[0]-1 -1.38282776e-05
x[n-1]-1 -1.89848137e-14 x[n-1]-1 -7.51018524e-06
Same Different
Android x86 Java on Core 2 Android x86 Java on Atom
Speed 53.27 MFLOPS Speed 15.65 MFLOPS
norm. resid 1.8 norm. resid 1.8
resid 8.03801470e-14 resid 8.03801470e-14
machep 2.22044605e-16 machep 2.22044605e-16
x[0]-1 3.55271368e-14 x[0]-1 3.55271368e-14
x[n-1]-1 3.44169138e-14 x[n-1]-1 3.44169138e-14
Different Different
|
To Start
Linpack Benchmark Results
MFLOPS results for the four Android versions are provided below. Also shown are those for PCs, compiled for Windows and Linux, the benchmarks being downloadable via
Linpack Results.htm. Java results for PCs were from using
Linpack Java Applet from Netlib and Android x86.
The most popular Android Linpack benchmark appears to be from
GreeneComputing.
This is a Java variety and produces similar performance ratings to my LinpackJava on T1 and T2 as quoted below.
The former also has a multi-processor test but it is not clear whether it uses multiple threads on a single program, or multiple copies of the program, where results and not really representative for comparing with published MP speeds.
Using compiled C programs a Cortex-A9 can be nearly as fast as an Atom running at the same MHz, but this is not the case with Java. Unlike Intel, it seems that the double precision version can be much slower than using single precision calculations.
The T4 and T7 v7-A9 CPUs again appear to be slow at 1200 MHz but T2, T6 and P11 seem to be at full speed.
The Qualcomm CPU performs well on this benchmark.
August 2013 - Tablet T11, with the Cortex-A15 CPU, runs at 2.5 times the speed of an A9 processor of the same MHz (if one existed), using the most recent floating point instructions. Linpack benchmark results are often quoted for ARM based systems, probably a design consideration.
The benchmark code has been modified to use NEON intrinsic functions that carry out four arithmetic operations simultaneously. See
android neon benchmarks.htm . For the new benchmark
Download NEON-Linpack.apk.
Results from this are included below.
To Start
Dhrystone 2 Benchmark
The Dhrystone "C" benchmark provides a measure of integer performance (no floating point instructions). It became the key standard benchmark from 1984, with the growth of Unix systems. The first version was produced by Reinhold P. Weicker in ADA and translated to "C" by Rick Richardson. Two versions are available - Dhrystone versions 1.1 and 2.1.
The second version, used here, was produced to avoid over-optimisation problems encountered with version 1, but some is still possible.
Because of this, optimised and non-optimised compilations are provided. Speed was originally measured in Dhrystones per second. This was later changed to VAX MIPS by dividing Dhrystones per second by 1757, the DEC VAX 11/780 result, the latter being regarded as the first 1 MIPS minicomputer.
The optimised .apk app file (DS2) can be downloaded from
www.roylongbottom.org.uk/Dhrystone2.apk
and the non-optimised one (DSN) from
www.roylongbottom.org.uk/Dhry2Nopt.apk.
Further details of the Dhrystone benchmark, and results from Windows and Linux based PCs, can be found in
Dhrystone Results.htm.
The same format Java front end, described above, is used, with the two C programs compiled using Android NDK. Examples of results is below, the Emailed version including the standard System Information.
Dhrystone 2 Benchmark 10-Feb-2012 19.08 Dhry2 NoOpt Benchmark 14-Feb-2012 12.15
Nanoseconds one Dhrystone run 592 Nanoseconds one Dhrystone run 1244
Dhrystones per Second 1689546 Dhrystones per Second 804020
VAX MIPS rating 962 VAX MIPS rating 458
|
To Start
Dhrystone 2 Benchmark Results
Unlike when using floating point, on this benchmark, the Cortex-A9 CPU is less than three times faster than the 926EJ on all measurements, a ratio similar to that provided by the BogoMIPS results, shown in System Information.
Measurements for Intel Atom and Core 2 CPUs are also provided for Windows (Watcom 32 Bit) and Linux (GCC 32 Bit and 64 Bit) compilations.
Core 2 results show considerable variations, highlighting the Danger, in comparing results from different compilers.
In this case, the significant difference is between 32 and 64 bit compilations under Linux, where far more registers are available for optimisation at 64 bits. On using them, the compiler might decide that multiple passes are not needed and remove repetitive calculations. Also, historically, computer manufacturers are known to have optimised their own compilers to inflate speeds of standard benchmarks.
Here, the optimised benchmark produces up to 1.4 Vax MIPS/MHz for the Cortex-A9. ARM, themselves, quote 2.5 Vax MIPS (DMIPS) per MHz for the same processor, probably just another different compiler variation.
Note the speed on tablet T5. This uses a MIPS CPU and requires an emulator to execute compiled ARM processor instructions.
T5a results are for an identical tablet, from a different user, but with no details of settings used.
The T4 and T7 v7-A9 CPUs again appear to be slow at 1200 MHz but T2 and P11 seem to be at full speed.
August 2013 - Tablet T11, with the Cortex-A15, is 30% to 40% faster than would be expected from the last generation of ARM processors.
Below are other results from http://gamma0burst.tistory.com in Korea (including some of mine). These provide better identification of the processors used. There are wide variations in results of what should be identical CPUs but, as with all benchmarks reported here, the systems might not be running at the specified clock frequency or might need a Setting to run at maximum speed.
Opt No Opt
System ARM MHz Android Vax Vax Bogo
See MIPS MIPS MIPS
T1 926EJ 800 2.2 356 196 798
T2 v7-A9 800 2.3.4 962 458 2036
P13 v7-A9 1200 4.1.2 1491 1592
P14 v7-A93 ? 4.2.3 645 2000
T4 v7-A9 1500a 4.0.3 1650 786 2394
T7 v7-A9 1300a 4.1.2 1610 810 1994
T11 v7-A15 2000b 4.2.2 3189 1504 998
P11 v7-A93 1400 4.0.4 1937 866 2786
EP1 926EJ Emul 2.2 227 122
ET2 v7-A8 Emul 4.03 286 160
Measured MHz a=1200, b=1700
T5 MIPS CPU 1000 4.01 56 1006
T5a MIPS CPU 1000 4.01 213 1006
T5a MIPS CPU 1000 4.01 70 1006
BS1 Emul Ph 3000 2.3.4 484
BS2 Emul C2 1833 2.3.4 150
32 Bit Atom 1666 Linux 2055 1194
64 Bit Atom 1666 Linux 2704 1098
32 Bit Atom 1666 Windows 1948 780
32 Bit Core 2 2400 Linux 5852 3348
64 Bit Core 2 2400 Linux 12265 3288
32 Bit Core 2 2400 Windows 6466 1251
System - T = Tablet, P = Phone, E = Emulator
Processor MHz Cores VAX MIPS
MIPS /MHz
Sam Exynos 4210 Cortex-A9 1200 2 1491 1.24
1200 2 1900 1.58
1400 2 1450 1.04
Sam Exynos 4412 Cortex-A9 1400 4 1740 1.24
1400 4 1937 1.38
Aml AML 8726-MX Cortex-A9 1500 2 1650 1.10
TI OMAP 4430 Cortex-A9 1200 2 1409 1.17
1200 2 1662 1.39
nV Tegra 3 Cortex-A9 1300 4 1610 1.24
Sam Exynos 5250 Cortex-A15 1700 2 3200 1.88
1700 2 3687 2.17
QSn S1 QSD 8250 Scorpian 1000 1 880 0.88
QSn S4 APQ 8064 Krait 1500 4 2417 1.61
1500 4 2555 1.70
QSn S4 APQ 8064T Krait 1700 4 2563 1.51
QSn S4 MSM 8960 Krait 1500 2 2229 1.49
QSn - Qualcomm Snapdragon, Sam - Samsung, Aml - Amlogic,
Ti - Texas Instruments, nV - nVidia
|
To Start
Livermore Loops Benchmark
This original main benchmark for supercomputers was first introduced in 1970, initially comprising 14 kernels of numerical application, written in Fortran. This was increased to 24 kernels in the 1980s. Performance measurements are in terms of Millions of Floating Point Operations Per Second or MFLOPS. The kernels are executed three times with different double precision data array sizes.
Following are overall MFLOPS results for various systems, geometric mean being the official average performance.
[Reference - F.H. McMahon, The Livermore Fortran Kernels: A Computer Test Of The Numerical Performance Range, Lawrence Livermore National Laboratory, Livermore, California, UCRL-53745, December 1986]
---------------- MFLOPS ---------------
CPU MHz Maximum Average Geomean Harmean Minimum Measured in
CDC 6600 10 1.1 0.5 0.5 0.4 0.2 1970 *
CDC 7600 36.4 7.3 4.2 3.9 2.5 1.4 1974 *
Cray 1A 80 83.5 25.8 14.4 7.9 2.7 1980 *
Cray 1S 80 82.1 22.2 11.9 6.5 1.0 1985
CDC Cyber 205 50 146.9 36.4 14.6 5.0 0.6 1982 *
Cray 2 244 146.4 36.7 14.2 5.8 1.7 1985
Cray XMP1 105 187.8 61.3 31.5 15.6 3.6 1986
* Fewer than 24 Kernels
For Cray 1 comparison purposes, it is more appropriate to use Cray 1S results, as these are from running all 24 kernels.
See below for best results so far, currently T4 using one of the two 1500 MHz cores, where performance equates to 15.5 times a Cray 1. Cost of this tablet was $130, in May 2012. Cray 1 was $7M.
The benchmark execution file can be downloaded from
www.roylongbottom.org.uk/LivermoreLoops.apk.
Further details of the Livermore Loops benchmark, and results from Windows and Linux based PCs, can be found in
Livermore Loops Results.htm.
The same format Java front end, described above, is used, with the C program compiled using Android NDK. An example of results is below, the Emailed version including the standard System Information.
800 MHz ARM Cortex-A9
Android Livermore Loops Benchmark 12-Feb-2012 21.55
MFLOPS for 24 loops Do Span 471
172.6 127.5 253.2 248.6 71.6 141.2
197.6 190.4 202.3 109.2 55.2 51.2
54.1 51.5 100.0 144.1 192.1 139.4
130.1 105.4 111.2 63.1 136.3 56.8
Overall Weighted MFLOPS Do Spans 471, 90, 19
Maximum Average Geomean Harmean Minimum
253.2 129.3 115.3 101.6 46.7
Results of last two calculations
4.850340602749970e+02 1.300000000000000e+01
Total Elapsed Time 11.9 seconds
|
So far, numeric results of the last two calculations have been identical on all benchmark runs.
To Start
Livermore Loops Benchmark Results
System T2, with the high speed vfpv3 hardware, is again shown to be around 20 times faster than the tablet T1, on these floating point calculations.
Relative to CPU MHz, T2 performs better than v7-A9 CPUs T4 and T7 and P8 Qualcomm, but P11 outshines them all. This benchmark has some L2 cache speed dependency. This cache is shown to be particularly fast on later benchmarks.
August 2013 - again, it is pointed out that tablet T11, with the Cortex-A15, is really running at 1700 MHz (not 2000), and some Cortex-A9s, used for comparison, are at 1200 MHz. This A15 is the first ARM processor to demonstrate more than 1 GFLOPS, on this benchmark. On a per MHz basis, the results demonstrate a wide range of relativity to A9s, varying from slighly slower to 3.4 times faster, the official average showing an improvement of 50%. Then, the system is also running at a higher MHz.
This benchmark is one of those that failed to use fast vfpv3 hardware under Android 4, Ice Cream Sandwich. In this case, a revised compilation procedure lead to the hardware being used with appropriate faster performance. The procedure was to compile a program that used vfpv3, then replace the Java and C code with that for the benchmark (see below).
To Start
MemSpeed Benchmark
This benchmark measures data reading speeds in MegaBytes per second carrying out calculations on arrays of cache and RAM data, sized 2 x 8 KB to 2 x 32 MB. Calculations are x[m]=x[m]+s*y[m] and x[m]=x[m]+y[m], using double and single precision floating point and x[m]=x[m]+s+y[m] and x[m]=x[m]+y[m] with integers. Million Floating Point Operations Per Second (MFLOPS) speed can be calculated by dividing double precision MB/second by 8 and 16, for the two tests, and single precision speeds by 4 and 8. Assembly listings for integer tests show that Millions of Instructions Per Second (MIPS) can be found by multiplying MB/second by 0.78 with 2 adds and 0.66 for the other test. Cache sizes are indicated by varying performance as memory usage changes.
Results below show maximum MFLOPS and MIPS speeds. The first integer test loop has 25 assembler type instructions, comprising 8 loads (x 4 bytes), 11 adds (8 data, 2 addresses, 1 loop increment), 4 stores, 1 compare, 1 branch), or an instructions/bytes ratio of 0.78125.
Best Cortex-A9 MIPS/MHz ratio is 1.59.
Using L1 cache data, performance differences on Cortex CPUs are similar to the benchmarks above. In the case of the Qualcomm Snapdragon, floating point tests are significantly faster, relative to CPU MHz, but a little slower using integers.
Other than comparisons with the Snapdragon CPU, P11, the Galaxy SIII, provides a significant performance gain using L2 cache. This might be due to the claimed use of 128-bit internal buses, instead of 64-bit.
The most outstanding results for P11 are using memory, typically three times faster than other A9s, and these might be aided by the L2 cache arrangement. P11 is said to have dual channel memory and, although not always stated, others have a single channel (see Memory and Bus Speed Calculations below).
August 2013 - T11, with the Cortex-A15, provides the fastest speeds reported here. Again, more than 1 GFLOPS is demonstrated, but this time with single precision calculations. Compared with P11, the last leader, and adjusting to compare at the same clock speed, memory speeds are similar, but the T11 is 2 to 3 times faster on double precision calculations, 3 to 4 times at single precision and 1.5 to twice as fast with integers.
This A15 obtains 1.8 MIPS/MHz.
The app can be downloaded from
www.roylongbottom.org.uk/MemSpeed.apk.
The program code used is the same as
Linux Multithreading Benchmarks.htm
and (nearly)
MemSpd2k Results.htm.
Results on an Intel Atom, for a single thread, using the multithreading benchmark, are shown below. On a per MHz basis, the Cortex-A9 performs well using L1 cache, comapared with the Atom but not always so with RAM based data.
Except for certain RAM tests, the Cortex-A15's performance is significantly better than the Atom.
T1, ARM 926EJ 800 MHz, Android 2.2, DDR2 RAM
Android MemSpeed Benchmark 17-Feb-2012 17.47
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 60 44 600 93 76 694
32 46 38 146 60 56 146
64 48 37 154 66 54 144
128 48 36 155 65 53 144
256 48 36 153 65 56 135
512 48 38 153 65 57 142
1024 47 37 153 65 57 142
4096 47 37 152 67 55 142
16384 47 37 152 70 63 138
65536 44 37 153 106 92 142
Total Elapsed Time 93.5 seconds
Maximum SP MFLOPS 11 Integer MIPS 468
T2, ARM Cortex-A9 800 MHz, Android 2.3.4 DDR2 RAM
Android MemSpeed Benchmark 17-Feb-2012 17.41
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 1002 533 1574 1742 812 1639
32 1042 530 1533 1717 701 1751
64 994 461 984 1144 644 942
128 656 396 691 696 511 673
256 269 259 273 271 255 280
512 249 246 244 256 244 247
1024 249 249 244 240 253 244
4096 246 244 247 246 242 245
16384 253 236 252 254 241 246
65536 254 241 253 250 252 241
Total Elapsed Time 19.4 seconds
Maximum SP MFLOPS 133 Integer MIPS 1228
T4, ARM Cortex-A9 1500 MHz, Android 4.0.3 DDR3 RAM
Measured 1200 MHz
Android MemSpeed Benchmark 11-May-2012 17.00
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 1631 834 2425 2700 1353 2799
32 1585 823 1863 2105 1185 2060
64 1265 724 1266 1532 982 1369
128 1311 715 1243 1480 963 1318
256 1229 697 1209 1295 938 1284
512 1044 579 1004 1203 680 1009
1024 473 405 474 482 430 474
4096 413 387 419 408 389 424
16384 410 386 423 408 382 422
65536 405 371 419 397 384 418
Total Elapsed Time 12.9 seconds
Maximum SP MFLOPS 209 Integer MIPS 1892
T7, ARM Cortex-A9 1300 MHz, Android 4.1.2, 1 GB DDR3 RAM
Measured 1200 MHz
Android MemSpeed Benchmark 17-Oct-2012 20.19
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 1735 888 2456 2726 1364 2818
32 1448 760 1474 1700 1039 1648
64 1318 719 1290 1468 952 1385
128 1279 715 1289 1443 944 1336
256 1268 714 1279 1435 943 1313
512 1158 691 1204 1321 892 1228
1024 729 553 735 772 632 742
4096 445 392 425 442 421 439
16384 435 390 428 435 412 431
65536 445 404 393 450 432 449
Total Elapsed Time 12.2 seconds
Maximum SP MFLOPS 222 Integer MIPS 1916
T8 Allwinner A13-MID, 1 GHz ARM Cortex-A8
Android MemSpeed Benchmark 1.1 05-Mar-2013 10.01
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 293 124 1376 481 241 1439
32 296 119 1389 482 230 1646
64 220 86 783 345 241 1301
128 288 122 1081 475 224 1288
256 233 106 462 315 197 513
512 188 98 256 247 168 276
1024 185 95 214 249 162 233
4096 183 98 228 248 163 236
16384 174 96 228 234 163 234
65536 183 98 206 243 155 214
Total Elapsed Time 29.8 seconds
Maximum SP MFLOPS 31 Integer MIPS 1075
T9 ARM 926EJ 800 MHz, Android 2.2
Android MemSpeed Benchmark 1.1 09-jul-2013 22.59
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 52 36 510 61 67 579
32 41 30 129 52 48 129
64 35 33 133 54 47 125
128 41 25 126 58 47 124
256 43 31 134 53 49 119
512 43 35 154 65 56 144
1024 47 38 153 65 56 146
4096 48 38 153 67 58 144
16384 43 37 152 73 63 144
65536 47 37 152 106 92 146
Total Elapsed Time 102,2 seconds
Maximum SP MFLOPS 11 Integer MIPS 398
T11 Samsung EXYNOS 5250 2000 MHz Cortex-A15, Android 4.2.2
Measured 1700 MHz
Android MemSpeed Benchmark 1.1 09-Aug-2013 17.04
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 7296 4159 3513 9375 5453 6211
32 7253 4540 3882 7364 4873 4839
64 6902 4265 3878 7026 4373 4274
128 6735 4032 2480 4005 2797 3288
256 5859 3775 2192 4527 3263 3676
512 5795 3781 3568 6282 3819 3818
1024 2609 1757 1754 2607 1805 1825
4096 1614 1422 1471 1654 1342 1441
16384 1624 1412 1474 1642 1336 1443
65536 1617 1408 1479 1368 1321 1423
Total Elapsed Time 10.7 seconds
Maximum SP MFLOPS 1135 Integer MIPS 3028
P6, Qualcomm S4 1500 MHz, Android 4.0.3, 1 GB DDR2 RAM
Android MemSpeed Benchmark 07-Jun-2012 09.45
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 2564 1428 1600 3697 1947 1894
32 2003 1381 1006 2432 1489 1118
64 1864 1284 1011 2378 1448 834
128 1868 1289 1004 2343 1431 1110
256 1865 1288 1010 2379 1442 1117
512 1853 1274 1004 2372 1429 1115
1024 855 731 658 941 782 694
4096 674 604 553 731 642 556
16384 668 605 554 730 640 585
65536 672 602 557 728 639 590
Total Elapsed Time 10.6 seconds
Maximum SP MFLOPS 357 Integer MIPS 1248
P8 Qualcomm Snapdragon, 1.5 GHz, Android 4.0.3, DDR2
Android MemSpeed Benchmark 10-Jul-2012 22.10
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 3636 2162 2509 4782 3181 2796
32 3109 1900 1512 3823 2330 1725
64 2931 1792 1514 3744 2277 1717
128 2927 1809 1512 3747 2276 1723
256 2920 1817 1506 3732 2269 1716
512 2320 1581 1345 2753 1894 1497
1024 1101 934 859 1161 1000 884
4096 902 823 766 965 830 777
16384 923 818 754 957 829 774
65536 926 821 754 957 827 776
Total Elapsed Time 10.4 seconds
Maximum SP MFLOPS 541 Integer MIPS 1957
P10 Qualcomm Snapdragon, 1.5 GHz, Android 4.0.3, DDR2
Android MemSpeed Benchmark 25-Sep-2012 09.05
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 3048 2203 2559 5452 3168 2784
32 2823 1720 1504 3827 2328 1723
64 2662 1787 1505 3793 2269 1716
128 2654 1812 1511 3800 2235 1717
256 2812 1808 1505 3793 2280 1709
512 2343 1580 1336 2833 1875 1496
1024 1177 966 876 1245 1012 916
4096 802 785 730 910 779 750
16384 882 722 729 913 791 745
65536 873 732 722 906 645 744
Total Elapsed Time 10.8 seconds
Maximum SP MFLOPS 550 Integer MIPS 1996
P11 ARM Cortex-A9 1.4 GHz, Android 4.0.4, DCDDR2
Android MemSpeed Benchmark 23-Dec-2012 15.16
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 983 926 2849 3162 1578 3265
32 1825 911 1694 2084 949 1892
64 1810 894 1654 1999 1174 1659
128 1816 867 1599 1945 1168 1758
256 1813 870 1596 1931 1162 1765
512 1802 868 1570 1779 1098 1740
1024 1569 828 1474 1776 1110 1634
4096 1362 817 1105 1310 1066 1335
16384 1287 825 1304 1338 926 1319
65536 1319 824 1298 1294 1072 1284
Total Elapsed Time 12.0 seconds
Maximum SP MFLOPS 231 Integer MIPS 2222
Atom 1666 MHz, DDR2 RAM 800 MHz, Linux
16 1892 943 1979 2759 1329 2813
64 1647 879 1690 2334 1269 2323
65535 1515 834 1517 2010 1208 1945
|
To Start
Memory and Bus Speed Calculations
Some assumptions regarding memory and bus speeds are aired here, based on knowledge provided for mainstream PCs, Google searches and results below. Whereas PC memory bus width is 8 bytes (per channel), that for these ARM systems is 4 bytes or less, considerably reducing relative maximum memory data transfer speeds.
As with PCs, data is read in bursts and this is normally clear from BusSpeed results, from which maximum data transfer speeds can be estimated. Suggested burst size for System T1 is 8 words or 32 bytes with maximum speed of 29 x 8 or 232 MB/second. For T2 and T4, 16 byte bursts are suggested with maximum speed between 35 x 16 to 39 x 16 or 560 to 624 MB/second. One reason for not achieving this performance is startup delays (CAS Latency - number of bus clocks).
It seems to be extremely difficult to obtain details of bus speeds and channel/bus configurations for Android devices. T7 appears to have single channel, double data rate 1333 MHz RAM, where maximum speed would be 666.7 (clock MHz) x 2 (DDR) x 4 (32 bit wide bus) = 5.33 GB/second. Then P11, with dual channel, DDR 1066 MHz RAM, could produce 533 x 2 x 2 (channels) x 4 = 8.53 GB/second. Speed estimated from burst tests and real measurements are nowhere near these maximum speeds but can be much faster using the
MultiThreading Benchmark version.
There are startup delays on transferring bursts of data, usually associated with the number of bus clocks under the heading of CAS Latency. With DDR, a one clock overhead can reduce data transfer rate by 33%. Measured maximum speed reading all data can also be much lower than that derived from burst reading tests, due to various internal processor delays. For examples see the AndI 2Reg and AndI 1Reg) in
BusSpd2K Memory Speed Results.
To Start
BusSpeed Benchmark
This benchmark is designed to identify reading data in bursts over buses. The program starts by reading a word (4 bytes) with an address increment of 32 words (128 bytes) before reading another word. The increment is reduced by half on successive tests, until all data is read. On reading data from RAM, 64 Byte bursts are typically used. Then, measured reading speed reduces from a maximum, when all data is read, to a minimum on using 16 word increments (64 bytes). Potential maximum speed can be estimated by multiplying this minimum value by 16. With this burst rate, measured speed at 32 word and 16 word increments are likely to be the same. Cache sizes are indicated by varying speed as memory use changes. Note, with smallest L1 cache demands, measured speed can be low due to overheads when reading little data.
The program C source code is as used for Linux, See
BusSpd2K Results.htm.
This has unrolled loops with up to 64 AND statements (& array[i ] to & array[i+63]). The Linux compiler for Intel CPUs translates this into 64 assembly instructions ANDing data from indexed memory locations.
In this case, Integer MIPS approximately equals MB/second divided by 4.
The Android NDK compiler generates 133 assembler type instructions, including 64 loads and 64 ANDs, where MIPS equates to MB/second divided by 1.92 (64 x 4 / 133) - twice as many instructions as Intel. Maximum MIPS and MIPS/MHz details have been added to the results below.
With data from L1 cache, tablets T4 and T7 again produce lower performance than might be expected, compared with CPU MHz with T6 better, compared with P11. The Qualcomm Snapdragon results are also on the low side, and it appears to have burst reading from L1 cache, with much lower data transfer speeds with the highest incremented addressing.
As with MemSpeed, the upgraded Cortex-A9 CPU in P11 provides significant performance gains using L2 cache and RAM.
Unlike using L1 cache, the Qualcomm CPU provides superior performance at high address increments.
August 2013 - T11, with the EXYNOS running at 1700 MHz, produces the best integer performance so far, or a maximum of 3224 MIPS or 1.9 MIPS per MHz. This can be compared with P11 Cortex-A9 at 1400 MHz, that reaches 2205 MIPS or 1.6 MIPS per MHz. T11’s L2 cache is even more efficient at twice the speed of P11, after adjusting for the same CPU MHz.
The original benchmark application can be downloaded from
www.roylongbottom.org.uk/BusSpeed.apk.
and the Android 4 version from
www.roylongbottom.org.uk/BusSpeedv7.apk.
T1, ARM 926EJ 800 MHz, Android 2.2, DDR2 RAM
Android BusSpeed Benchmark 19-Feb-2012 13.47
Reading Speed 4 Byte Words in MBytes/Second
Memory Inc32 Inc16 Inc8 Inc4 Inc2 Read
KBytes Words Words Words Words Words All
16 96 95 199 407 426 467
32 35 34 34 68 124 201
64 29 29 30 58 108 174
128 30 30 29 57 108 182
256 29 30 30 56 107 169
512 28 29 29 57 106 181
1024 28 29 29 55 99 176
4096 28 29 29 57 106 177
16384 28 28 29 53 103 181
65536 28 29 29 56 106 179
Total Elapsed Time 6.3 seconds
Maximum MIPS - 243 MIPS/MHz - 0.3
T2, ARM Cortex-A9 800 MHz, Android 2.3.4, DDR2 RAM
Android BusSpeed Benchmark 19-Feb-2012 14.00
Reading Speed 4 Byte Words in MBytes/Second
Memory Inc32 Inc16 Inc8 Inc4 Inc2 Read
KBytes Words Words Words Words Words All
16 1748 1347 2154 2331 2331 2285
32 1038 1446 1474 1678 1735 1899
64 407 490 508 592 489 826
128 180 213 183 258 266 530
256 47 42 57 83 79 132
512 41 39 47 73 68 137
1024 39 38 52 70 57 135
4096 38 26 60 69 67 115
16384 39 32 59 71 59 135
65536 34 33 59 67 63 123
Total Elapsed Time 6.9 seconds
Maximum MIPS - 1211 MIPS/MHz - 1.5
Typical variation in results
16 403 421 503 2316 2331 2285
32 1344 1446 1428 1658 1750 1943
Android 4 early version failed to select library for high speed hardware
T4, ARM Cortex-A9 1500 MHz, Android 4.0.3, DDR3 RAM
Measured 1200 MHz
Android BusSpeed Benchmark 11-May-2012 17.13
Reading Speed 4 Byte Words in MBytes/Second
Memory Inc32 Inc16 Inc8 Inc4 Inc2 Read
KBytes Words Words Words Words Words All
16 723 1106 1045 1124 1209 1840
32 613 635 693 1063 1090 1693
64 179 175 184 300 474 871
128 163 154 167 255 416 776
256 137 155 166 261 444 801
512 41 42 95 165 293 542
1024 22 21 63 115 211 400
4096 19 17 57 107 199 367
16384 16 16 56 107 199 340
65536 18 16 54 99 184 342
Total Elapsed Time 5.8 seconds
Maximum MIPS - 956 MIPS/MHz - 0.6
This tablet using Android 4.1.2 Jelly Bean recognises the library to use high speed hardware
T7, ARM Cortex-A9 1300 MHz, Android 4.1.2, 1 GB DDR3 RAM
Measured 1200 MHz
Android BusSpeed Benchmark 19-Oct-2012 17.29
Reading Speed 4 Byte Words in MBytes/Second
Memory Inc32 Inc16 Inc8 Inc4 Inc2 Read
KBytes Words Words Words Words Words All
16 2723 2420 3044 3364 3499 3500
32 1054 1087 1061 1382 1565 2145
64 436 433 419 652 751 1160
128 345 337 337 542 633 943
256 329 309 322 522 614 961
512 339 299 311 506 574 937
1024 170 168 180 269 349 629
4096 59 55 84 127 176 338
16384 56 56 83 125 173 335
65536 56 56 82 125 174 334
Total Elapsed Time 5.7 seconds
Maximum MIPS - 1818 MIPS/MHz - 1.5 at 1200
T8 Allwinner A13-MID, 1 GHz ARM Cortex-A8
Android BusSpeed Benchmark 1.1 v7 05-Mar-2013 10.00
Reading Speed 4 Byte Words in MBytes/Second
Memory Inc32 Inc16 Inc8 Inc4 Inc2 Read
KBytes Words Words Words Words Words All
16 1519 1561 1611 1650 1129 1599
32 1091 1153 1075 1562 1668 1594
64 253 274 298 716 665 1237
128 61 56 108 244 422 705
256 37 37 71 139 268 439
512 22 22 41 89 166 319
1024 19 19 28 76 146 285
4096 17 17 32 69 133 262
16384 17 16 35 67 107 258
65536 17 15 32 59 119 221
Total Elapsed Time 6.8 seconds
Maximum MIPS - 832 MIPS/MHz - 0.8
T11 Samsung EXYNOS 5250 2.0 GHz Cortex-A15, Android 4.2.2
Measured 1.7 GHz
2 GB DDR3-1600 RAM, dual channel, 12.8 GB/sec
Android BusSpeed Benchmark 1.1 v7 09-Aug-2013 17.07
Reading Speed 4 Byte Words in MBytes/Second
Memory Inc32 Inc16 Inc8 Inc4 Inc2 Read
KBytes Words Words Words Words Words All
16 3193 3451 4412 5272 5389 6191 L1
32 1298 1558 1990 3478 4264 4420
64 804 928 1209 2442 3263 3426 L2
128 784 904 1175 2321 3148 3333
256 780 908 1181 2336 3142 3327
512 788 907 1165 2312 3120 3300
1024 360 387 384 803 1348 1744
4096 145 146 194 507 648 1378 RAM
16384 141 136 190 507 638 1373
65536 142 141 191 506 643 1371
Total Elapsed Time 5.3 seconds
Maximum MIPS - 3224 MIPS/MHz - 1.9 at 1700
P10 Qualcomm Snapdragon, 1.5 GHz, Android 4.0.3, DDR2
Android BusSpeed Benchmark 25-Sep-2012 09.04
Reading Speed 4 Byte Words in MBytes/Second
Memory Inc32 Inc16 Inc8 Inc4 Inc2 Read
KBytes Words Words Words Words Words All
16 365 508 973 1462 1529 1274 L1
32 368 168 486 598 858 857 L2
64 358 445 509 605 860 958
128 389 459 508 602 873 785
256 391 461 518 611 873 956
512 258 335 363 471 527 749
1024 92 143 137 222 382 230 RAM
4096 69 101 96 127 277 441
16384 78 101 99 146 251 406
65536 67 97 97 144 257 404
Total Elapsed Time 5.8 seconds
Maximum MIPS - 662 MIPS/MHz - 0.4
Recompiled to produce just library that uses high speed hardware
T4, ARM Cortex-A9 1500 MHz, Android 4.0.3, DDR3 RAM
Measured 1200 MHz
ICS Settings, Developer Options, CPU Mode, Performance
Android BusSpeed Benchmark v7 19-May-2012 19.15
Reading Speed 4 Byte Words in MBytes/Second
Memory Inc32 Inc16 Inc8 Inc4 Inc2 Read
KBytes Words Words Words Words Words All
16 2747 2934 3380 3643 3635 3640 L1
32 1897 2151 2137 2457 2632 2987
64 573 577 596 732 782 1193 L2
128 513 505 501 641 676 1066
256 502 490 488 610 653 935
512 177 166 231 367 465 765
1024 39 39 72 144 267 469 RAM
4096 35 35 61 126 241 429
16384 35 35 61 127 241 430
65536 35 34 60 127 240 431
Total Elapsed Time 5.4 seconds
Maximum MIPS - 1891 MIPS/MHz - 1.6 at 1200
Maximum RAM speed estimate 35 x 16 = 560 MB/s
T4, ICS Settings, Developer Options, CPU Mode, Normal
16 418 462 532 651 737 780
32 422 462 571 704 678 1166
64 228 221 237 306 325 477
128 285 266 317 409 414 767
256 353 376 380 473 562 849
512 74 67 127 236 369 629
1024 41 41 74 148 268 476
4096 35 35 61 124 241 435
16384 35 35 61 113 239 431
65536 34 35 61 126 241 413
T7, ARM Cortex-A9 1300 MHz, Android 4.1.2,
Measured 1200 MHz
1 GB DDR3L-1333 RAM, single channel, 5.3 GB/sec
Android BusSpeed Benchmark v7 19-Oct-2012 17.38
Reading Speed 4 Byte Words in MBytes/Second
Memory Inc32 Inc16 Inc8 Inc4 Inc2 Read
KBytes Words Words Words Words Words All
16 2457 2740 3135 3312 3362 3413
32 1852 2113 2031 2357 2543 2974
64 415 414 410 640 697 1131
128 337 333 334 541 635 993
256 331 319 325 522 623 981
512 335 318 322 508 608 951
1024 228 228 234 332 411 729
4096 59 58 83 127 176 340
16384 57 56 83 125 175 337
65536 56 57 83 125 173 310
Total Elapsed Time 5.7 seconds
Maximum MIPS - 1773 MIPS/MHz - 1.5 at 1200
T6, ARM Cortex-A9 1600 MHz, nVidia Tegra 3,
32-bit single-channel 667 x 2 MHz DDR3, Android 4.0.3
Android BusSpeed Benchmark v7 26-Aug-2012 14.05
Reading Speed 4 Byte Words in MBytes/Second
Memory Inc32 Inc16 Inc8 Inc4 Inc2 Read
KBytes Words Words Words Words Words All
16 3850 4181 4752 5121 5126 5119 L1
32 994 873 897 1356 1496 1827
64 574 583 608 872 985 1533 L2
128 460 461 467 677 762 1225
256 427 425 449 666 754 1196
512 426 423 442 659 726 1189
1024 194 189 210 312 392 707
4096 67 67 98 142 198 392 RAM
16384 66 65 96 140 197 388
65536 66 64 96 139 197 326
Maximum MIPS - 2659 MIPS/MHz - 1.7
P16 LG G2X Dual-channel RAM Dual-core Cortex-A9 1 GHz
Android 2.3.4
Android BusSpeed Benchmark V1.1 16-Mar-2013 02.43
Reading Speed 4 Byte Words in MBytes/Second
Memory Inc32 Inc16 Inc8 Inc4 Inc2 Read
KBytes Words Words Words Words Words All
16 2254 2429 2798 2965 2970 2988 L1
32 822 894 906 1095 1186 1683
64 413 461 482 520 525 846 L2
128 362 404 405 442 449 755
256 356 251 412 446 447 745
512 348 377 404 437 445 743
1024 183 212 256 240 112 713
4096 105 114 137 279 376 652 RAM
16384 104 113 135 272 380 652
65536 95 113 135 276 379 653
Total Elapsed Time 5.3 seconds
Maximum MIPS - 1556 MIPS/MHz - 1.6
P11, ARM Cortex-A9 1.4 GHz, Android 4.0.4
Dual Channel DDR2
Android BusSpeed Benchmark 23-Dec-2012 15.04
Reading Speed 4 Byte Words in MBytes/Second
Memory Inc32 Inc16 Inc8 Inc4 Inc2 Read
KBytes Words Words Words Words Words All
16 3174 3050 3938 4232 4104 4244 L1
32 1236 1350 1341 1572 1614 2190
64 834 817 871 1010 1118 1602 L2
128 734 748 720 955 981 1393
256 730 684 720 922 966 1379
512 709 733 691 904 769 1383
1024 138 311 425 674 874 1324
4096 100 93 204 385 743 1194 RAM
16384 99 90 202 350 739 1170
65536 92 89 200 366 736 1134
Total Elapsed Time 5.6 seconds
Maximum MIPS - 2205 MIPS/MHz - 1.6
P7? Unknown device. See Systems Used P7?
Android BusSpeed Benchmark v7 21-Jun-2012 09.07
Reading Speed 4 Byte Words in MBytes/Second
Memory Inc32 Inc16 Inc8 Inc4 Inc2 Read
KBytes Words Words Words Words Words All
16 1365 1374 1517 1552 1034 1600 L1
32 427 388 436 265 419 1548
64 165 168 176 219 279 267 L2
128 171 172 174 209 267 266
256 170 173 178 207 261 267
512 171 172 167 198 256 259
1024 55 144 145 181 229 233
4096 88 91 93 111 155 147 RAM
16384 86 95 90 110 153 149
65536 89 90 91 110 155 149
Total Elapsed Time 6.0 seconds
P8 Qualcomm Snapdragon S4, 1500 MHz
Android BusSpeed Benchmark v7 28-6?-2012 23.10
Reading Speed 4 Byte Words in MBytes/Second
Memory Inc32 Inc16 Inc8 Inc4 Inc2 Read
KBytes Words Words Words Words Words All
16 328 831 1708 2876 3263 3912 L1
32 664 699 807 1009 951 1810 L2
64 671 698 821 1012 1151 1834
128 548 613 703 1003 1041 1864
256 709 748 845 1024 1171 1862
512 582 665 736 916 1131 1816
1024 176 245 289 294 463 832
4096 119 175 210 202 330 610 RAM
16384 118 175 211 202 330 610
65536 120 175 211 202 330 611
Total Elapsed Time 5.3 seconds
Maximum MIPS - 2032 MIPS/MHz - 1.4
BS1 BlueStacks Emulator on 3 GHz Phenom
Android BusSpeed Benchmark v7 12-Oct-2012 16.41
Reading Speed 4 Byte Words in MBytes/Second
Memory Inc32 Inc16 Inc8 Inc4 Inc2 Read
KBytes Words Words Words Words Words All
16 1333 1462 1599 1629 1638 1600
32 1706 1666 1523 1777 1706 1707
64 1599 1777 1778 1706 1707 1832
128 1001 1023 1524 1707 1603 1603
256 1024 1143 1524 1603 1140 1433
512 853 853 1024 1464 1291 1565
1024 546 683 951 1172 1565 1730
4096 586 685 1101 1482 1527 1730
16384 367 419 734 1153 1537 1468
65536 233 419 734 1174 1438 1677
Total Elapsed Time 6.8 seconds
Atom 1666 MHz, DDR2 RAM 800 MHz, Linux
Reading Speed 4 Byte Words in MBytes/Second
Memory Inc32 Inc16 Inc8 Inc4 Inc2 Read
KBytes Words Words Words Words Words All
16 5024 5502 6040 6312 6382 6412
64 493 404 786 1485 2588 3941
65536 136 261 521 1036 2008 3295
Bus spec 400 x 2 (DDR) x 8 (bus width) = 6400 MB/s
Measured estimate 136 x 32 = 4352
261 x 16 = 4192
Maximum MIPS (6412/4) - 1603 MIPS/MHz - 0.96
|
To Start
Randmem Benchmark
RandMem benchmark carries out four tests at increasing data sizes to produce data transfer speeds in MBytes Per Second from caches and memory. Serial and random address selections are employed, using the same program structure, with read and read/write tests using 32 bit integers. The main purpose is to demonstrate how much slower performance can be through using random access. Here, speed can be considerably influenced by reading and writing in bursts, where much of the data is not used, and by the size of preceding caches.
The benchmark uses the first four tests described in
RandMem Results.htm
and can be downloaded from
www.roylongbottom.org.uk/RandMem.apk.
The program structure is as follows, with array xi indexing via sequential or random numbers stored in the array.
Read - toti = toti & xi[xi[i+0]] | xi[xi[i+2]
& xi[xi[i+4]] | xi[xi[i+4]] and &| to i+30
Read/write - xi[xi[i+2]] = xi[xi[i+0]];
xi[xi[i+6]] = xi[xi[i+4]]; repeated to i+30 and i+28
The results below show that random access performance is approximately the same as BusSpeed with address increments of 32 words, the burst reading effect.
This program is again based on indexed memory addressing where the older technology CPU can be faster than than the System T2. This might be due to poor implementation of the memory bus interface on this tablet, as noted on PC tests.
Atom results are provided, again showing better relative performance, particularly when using data from RAM.
As with BusSpeed, and not noticed so far on the other benchmarks, measured speeds using L1 cache are sometimes slow to start with.
Relative performance of Cortex CPUs is similar to the other memory tests. The Qualcomm Snapdragon performs very well on random access to L2 cache and RAM, repeating the effects of faster burst reading speed seen in BusSpeed.
August 2013 - Cortex-A15 based T11 again come out fastest at this time. Best comparative performance is for data using L2 cache, particularly with serial reading. where RAM speed comparisons are also good.
System T1, ARM 926EJ 800 MHz, Android 2.2
Android RandMem Benchmark 20-Feb-2012 16.51
MBytes/Second transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 841 1119 666 955
32 222 147 83 62
64 145 169 56 53
128 198 181 48 57
256 191 178 44 58
512 196 180 27 32
1024 189 180 22 26
4096 193 181 19 23
16384 195 177 19 22
65536 186 166 19 22
Total Elapsed Time 49.0 seconds
System T2, ARM Cortex-A9 800 MHz, Android 2.3.4
Android RandMem Benchmark 20-Feb-2012 16.45
MBytes/Second transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 1777 1879 1669 1809
32 1359 1394 1185 1505
64 799 861 621 755
128 394 202 295 333
256 147 146 92 104
512 133 136 71 42
1024 125 125 53 62
4096 129 98 41 53
16384 128 113 42 45
65536 121 115 30 32
Total Elapsed Time 15.7 seconds
System T4, ARM Cortex-A9 1500 MHz, Android 4.0.3
Measured 1200 MHz
Android RandMem Benchmark 11-May-2012 17.19
MBytes/Second Transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 2777 3014 2671 3021 L1
32 2254 2490 2062 2561
64 872 1109 875 998 L2
128 797 870 674 721
256 807 932 528 560
512 543 465 186 182
1024 388 241 78 83 RAM
4096 367 229 56 48
16384 366 229 48 45
65536 335 228 41 38
Total Elapsed Time 13.2 seconds
T7, ARM Cortex-A9 1300 MHz, Android 4.1.2,
Measured 1200 MHz
Android RandMem Benchmark 20-Oct-2012 11.14
MBytes/Second Transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 2788 3041 2795 3041 L1
32 2769 3011 2767 3020
64 1027 1038 839 911 L2
128 916 918 616 649
256 904 905 514 538
512 899 907 475 499
1024 712 699 345 354
4096 323 284 92 88 RAM
16384 316 282 73 70
65536 314 281 65 62
Total Elapsed Time 10.9 seconds
T6, ARM Cortex-A9 1600 MHz, Android 4.0.3, DDR3 RAM
Android RandMem Benchmark 26-Aug-2012 13.58
MBytes/Second Transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 3925 4257 3881 4275 L1
32 3867 4204 3864 3998
64 1276 1284 1042 1182 L2
128 1126 1133 775 844
256 1118 1121 641 706
512 1107 1113 584 655
1024 750 715 352 366
4096 362 314 103 97 RAM
16384 337 317 84 79
65536 369 317 75 71
Total Elapsed Time 10.3 seconds
T8 Allwinner A13-MID, 1 GHz ARM Cortex-A8
Android RandMem Benchmark 1.1 05-Mar-2013 10.03
MBytes/Second Transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 2032 2787 2057 2802 L1
32 2014 2736 1972 2668
64 458 309 92 141 L2
128 423 316 74 121
256 304 204 39 58 RAM
512 270 201 29 36
1024 267 192 27 39
4096 258 197 23 35
16384 247 206 22 34
65536 254 206 19 28
Total Elapsed Time 20.7 seconds
T11 Samsung EXYNOS 5250 2.0 GHz Cortex-A15, Android 4.2.2
Measured 1.7 GHz
Android RandMem Benchmark 1.1 13-Aug-2013 17.29
MBytes/Second Transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 2881 2478 3388 3650
32 4301 2968 3197 3249
64 3669 2511 2201 2249
128 3566 2560 1571 1566
256 3557 2461 1334 1256
512 3524 2547 1136 1098
1024 1933 1144 534 513
4096 1993 1064 184 173
16384 1970 1086 141 144
65536 1973 1117 106 104
Total Elapsed Time 9.1 seconds
P11, ARM Cortex-A9 1.4 GHz, Android 4.0.4
Android RandMem Benchmark 23-Dec-2012 15.18
MBytes/Second Transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 3253 3542 3255 3438 L1
32 2626 2794 2511 2945
64 1453 1471 1298 1467 L2
128 1298 1302 1030 1095
256 1279 1289 819 826
512 1054 1075 237 245
1024 1155 989 150 146
4096 1101 919 107 106 RAM
16384 1061 911 91 90
65536 1048 919 73 77
Total Elapsed Time 10.7 seconds
P10 Qualcomm Snapdragon, 1.5 GHz, Android 4.0.3, DDR2
Android RandMem Benchmark 25-Sep-2012 09.02
MBytes/Second Transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 1878 3732 2564 3081 L1
32 1545 1796 1258 1487 L2
64 1472 1797 1030 1205
128 1502 1769 869 1084
256 1548 1786 795 938
512 1323 1264 604 798
1024 745 697 230 268
4096 425 457 149 145 RAM
16384 481 458 120 130
65536 501 458 100 106
Total Elapsed Time 10.2 seconds
Atom 1666 MHz, DDR2 RAM 800 MHz, Linux
16 3976 5132 4100 5134
64 3086 3215 1042 1349
65536 2708 1290 49 74
|
To Start
DriveSpeed and DriveSpeed2 Benchmarks
Primarily to measuring performance of SD cards and internal drives, DriveSpeed carries out four tests.
Test 1 - Write and read three 8 and 16 MB; Results given in MBytes/second
Test 2 - Write 8 MB, read can be cached in RAM; Results given in MBytes/second
Test 3 - Random write and read 1 KB from 4 to 16 MB; Results are Average time in milliseconds
Test 4 - Write and read 200 files 4 KB to 16 KB; Results in MB/sec, msecs/file and delete seconds.
DriveSpeed was produced for early Android systems that had an internal drive and an external SD card. These were identified by specific programming functions and executed via two buttons RunI and RunS. The general form was that RunS used direct I/O, avoiding data being cached in RAM. but RunI used cached data. A More button was provided for the latter with choices of Don’t Delete and/or Read Only, allowing reading speed to be measured after rebooting. This is still available but has an added display to identify drive capacity and free space, helping to identify the drive/card used. The directory path for the device used is also shown.
With later versions of Android or system hardware, the internal drive could have the largest part operating as an SD drive and the remainder as a cached drive. The directory path used was also found to vary on different systems. DriveSpeed2 starts with an input request to type in the path. This can normally be found via a FileBrowser app. Then there are Run and Restart buttons, the latter to correct a false entry or to select a different drive. There is also a Save button to Email results (to me or/and whoever). These new procedures also allowed USB connected devices to be selected (in some cases).
The benchmark can be downloaded from the links
DriveSpeed
and
DriveSpeed2.
Below are examples of results. These include the usual configuration details (see above). Drive capacity and paths used for later example results are also provided.
Results
Android DriveSpeed2 Benchmark 1.0 29-Aug-2013 12.36
Data Not Cached
MBytes/Second
MB Write1 Write2 Write3 Read1 Read2 Read3
8 5.1 5.1 5.2 22.5 22.9 22.9
16 4.6 4.9 5.2 22.8 22.8 15.3
Cached
8 116.5 1.2 15.9 123.4 209.7 129.1
Random Write Read
From MB 4 8 16 4 8 16
msecs 2.27 2.34 2.95 0.01 0.01 0.02
200 Files Write Read Delete
File KB 4 8 16 4 8 16 secs
MB/sec 0.40 0.80 1.12 5.22 7.09 11.46
msecs 10.28 10.25 14.60 0.79 1.15 1.43 0.161
Total Elapsed Time 64.1 seconds
File Path Used - /mnt/flash/
Drive MB 2740 Free 2629
File Paths and Drive Capacity
System
See Android Drive MB Free Path
T1 2.2 External SD SD1 3897 3897 /sdcard/
T2 2.3.4 External SD SD2 15185 9393 /mnt/sdcard/
T4 4.0.3 External SD SD3 15258 14906 /mnt/sdcard/external_sdcard/
T11 4.2.2 External SD SD3 15258 14906 /mnt/extsd/
T11 4.2.2 USB SD SD3 15258 14906 /mnt/udisk/
T11 4.2.2 USB3 SD SD3 15258 14906 /mnt/udisk/
T2 2.3.4 USB SD SD4 15185 13869 /mnt/sdb/sdb1/
T11 4.2.2 External SD SD4 15185 13869 /mnt/extsd/
T11 4.2.2 USB SD SD4 15185 13869 /mnt/udisk/
T11 4.2.2 USB3 SD SD4 15185 13869 /mnt/udisk/
T1 2.2 Internal Drive ID1 1602 1459 /data/data/com.drivespeed2/
T2 2.3.4 Internal Drive ID2 702 492 /data/data/com.drivespeed2/
T2 2.3.4 Internal SD SDI2 2740 2629 /mnt/flash/
T4 4.0.3 Internal Drive ID4 802 689 /data/data/com.drivespeed2/files/
T4 4.0.3 Internal SD SDI4 13857 13682 /mnt/sdcard/
T7 4.3 Internal SD SDI7b 13676 12988 /storage/emulated/0/
T7 4.3 Internal Drive SDI7a 13676 12988 /data/data/com.drivespeed2/
T7 4.3 Internal Drive SDI7b 13676 12988 /mnt/sdcard/
T11 4.2.2 Internal SD SDI11 12757 9788 /sdcard/
T11 4.2.2 Internal Drive ID11 984 680 /data/data/com.drivespeed2/
T1 2.2 USB stick USBS1 7688 7029 /udisk/
T2 2.3.4 USB stick USBS1 7688 7019 /mnt/sda/sda1/
T4 4.0.3 USB stick USBS1 7688 7019 /mnt/sda1/
T11 4.2.2 USB stick USBS1 7688 7036 /mnt/udisk/
S3 is a Class 10 card with minimum 24 MB/second reading and 10 MB/second writing.
S4 is a Class 10 card at up to 95 MB/second reading and 90 MB/second writing.
Other cards are Class 4
|
To Start
DriveSpeed Benchmark Comparisons
The benchmark is a subset of a version produced for PCs, the Windows version drivespeed32.exe, found in
drivespeed32.zip,
with drivespeed32 and drivespeed64, Linux varieties, from
this tar.gz file.
The execution files can be copied to to Android drives and executed on a PC via a USB connection.
Details and results on a range of systems are provided in
linux_disk_usb_lan_benchmarks.htm.
Here, device "Sig" id the same USB stick as USBS1 below and is extremely slow on writing small files and deleting them via Windows. This is a Windows problem associated with too frequent updates of the File Allocation Table, under FAT formatting.
Large Files - The speed of large files on internal drives has been slow, compared with PC hard drives, but that on tablet T11 shows an improvement, where reading speeds can be 50 MB/second. However, SD4, the super fast SD card does not perform well as an external card. T11 also has a USB 3 connector, where reading speed can sometimes be similar to the internal drive but, in both cases, writing speed is disappointing.
Small Files - In the case of Sig, mentioned above, minimum time to write small files via Windows was around 300 milliseconds, but more modern memory can produce similar speeds to Android. For example, SD4 minimum time is around 17 milliseconds using the Windows version (USB2).
This is still excessive as hard drives can have a minimum of 0.5 milliseconds.
Cached Files - These are where Android is allowed to keep a copy of the data in main memory. Here, writing speeds can vary considerably, from just writing to memory, to saving to the drive. Reading performance can reflect memory speed.
Random Access - As shown in
Linux Results,
random writing speeds can be subject to extremely wide variations on flash drives, and random reading times can be less than on disk drives that are subject to rotational delays. Disk random reading speeds can be faster on small files, as the data is cached in a buffer.
Large Files
MB/sec 16 MB Files, ## 8 MB
Write1 Write2 Write3 Read1 Read2 Read3
T1 Ext SD1 3.4 4.2 4.2 8.7 8.7 8.3
T2 Ext SD2 3.4 3.4 3.4 7.6 7.5 7.5
T4 Ext SD3 5.6 6.3 6.3 10.5 10.7 10.8
T11 Ext SD3 5.4 8.3 8.7 20.7 20.6 20.7
T11 USB2 SD3 5.6 8.1 8.1 16.8 16.8 16.9
T11 USB3 SD3 7.1 8.6 8.3 17.2 17.2 17.5
T2 USB2 SD4 11.6 11.7 11.9 28.9 30.2 29.9
T11 Ext SD4 12.0 11.6 11.4 21.7 21.8 21.9
T11 USB2 SD4 14.0 17.7 18.5 25.9 26.1 25.9
T11 USB3 SD4 18.2 24.8 25.2 59.0 36.1 36.9
T1 USB2 USBS1 1.1 1.1 0.9 8.5 4.4 8.3
T2 USB2 USBS1 2.6 2.6 3.1 11.5 12.1 11.0
T4 USB2 USBS1 2.3 2.6 2.3 8.3 9.6 9.5
T11 USB2 USBS1 2.8 3.0 3.0 11.8 12.5 12.4
T2 Int SDI2 4.6 4.9 5.2 22.8 22.8 15.3
T4 Int SDI4 10.7 11.1 11.2 24.7 24.9 23.7
T11 Int SDI11 8.9 16.6 20.0 51.0 49.1 53.7
T1 cached ID1 ## 3.4 3.5 3.5 167.4 165.1 162.9
T1 cached ID1 3.4 3.4 3.3 8.2 8 8.2
T2 cached ID2 4.0 4.0 4.0 316.6 294.3 316.6
T4 cached ID4 109.3 124.4 16.6 227.5 213.8 236.2
T7 cached SDI7a 217.8 74.2 15.3 326.4 434.2 394.9
T7 cached SDI7b 60.6 53.3 14.4 95.7 92.4 86.0
T11 cached ID11 206.4 188.6 130.3 757.6 775.4 752
Random Access
milliseconds
Random Write Read
From MB 4 8 16 4 8 16
T1 Ext SD1 58.32 22.08 196.90 0.10 0.26 1.28
T2 Ext SD2 3.80 23.62 20.08 0.04 0.03 0.93
T4 Ext SD3 8.79 12.64 6.00 0.04 0.04 0.57
T11 Ext SD3 4.53 21.43 8.45 0.01 0.01 0.59
T11 USB2 SD3 8.35 4.25 20.65 0.02 0.03 0.77
T11 USB3 SD3 8.34 22.46 5.76 0.02 0.02 0.74
T2 USB2 SD4 2.40 5.02 3.28 0.01 0.01 0.03
T11 Ext SD4 3.50 3.34 2.69 0.01 0.01 0.48
T11 USB2 SD4 2.93 2.90 3.34 0.01 0.01 0.44
T11 USB3 SD4 3.49 2.60 2.03 0.01 0.01 0.05
T1 USB2 USBS1 361.65 389.22 384.42 1.14 0.07 1.06
T2 USB2 USBS1 36.26 208.72 344.72 0.03 49.56 1.16
T4 USB2 USBS1 53.51 112.59 316.58 3.39 1.69 0.92
T11 USB2 USBS1 29.41 206.32 220.73 0.02 50.90 1.20
T2 Int SDI2 2.27 2.34 2.95 0.01 0.01 0.02
T4 Int SDI4 2.60 2.97 2.95 0.01 0.01 0.27
T7 cached SDI7
T11 Int SDI11 2.05 2.5 1.92 0.01 0.01 0.01
T1 cached ID1 5.60 5.72 5.90 0.05 0.03 0.06
T2 cached ID2 3.10 3.09 3.03 0.01 0.01 0.01
T4 cached ID4 2.71 2.72 5.21 0.01 0.01 0.01
T7 cached SDI7a 2.22 4.16 2.01 0.00 0.00 0.00
T7 cached SDI7b 1.90 2.23 4.58 0.01 0.01 0.01
T11 cached ID11 1.91 2.53 3.14 0.00 0.00 0.00
Small Files
milliseconds
200 Files Write Read Delete
File KB 4 8 16 4 8 16 secs
T1 Ext SD1 47.06 33.10 41.39 1.80 2.48 3.31 0.852
T2 Ext SD2 23.33 29.48 35.71 1.13 1.65 2.81 0.962
T4 Ext SD3 29.69 47.67 36.08 1.48 3.39 3.38 1.439
T11 Ext SD3 32.55 32.24 33.47 1.61 1.82 2.39 1.750
T11 USB2 SD3 24.09 28.96 33.17 1.94 2.19 2.60 0.926
T11 USB3 SD3 25.69 35.26 33.95 1.91 2.15 2.58 0.926
T2 USB2 SD4 16.13 16.18 21.95 1.32 1.38 1.73 0.318
T11 Ext SD4 15.83 11.65 18.91 0.91 1.26 1.93 0.461
T11 USB2 SD4 12.71 11.04 15.27 1.30 1.45 1.75 0.278
T11 USB3 SD4 10.33 11.42 15.86 1.25 0.71 1.14 0.401
T1 USB2 USBS1 Timeout
T2 USB2 USBS1 42.31 29.23 29.92 2.63 2.92 2.98 1.594
T4 USB2 USBS1 53.71 30.00 34.22 2.57 4.33 5.38 1.845
T11 USB2 USBS1 35.85 23.11 25.17 2.59 2.93 3.61 1.242
T2 Int SDI2 10.28 10.25 14.60 0.79 1.15 1.43 0.161
T4 Int SDI4 1.29 4.62 5.40 0.16 0.56 0.92 0.075
T7 cached SDI7
T11 Int SDI11 11.10 12.90 14.40 0.62 0.94 1.38 0.450
T1 cached ID1 10.63 10.48 12.86 0.11 0.17 0.27 1.778
T2 cached ID2 28.09 22.13 12.91 0.03 0.05 0.08 5.324
T4 cached ID4 0.09 0.98 1.60 0.03 0.40 0.35 0.137
T7 cached SDI7a 0.13 0.32 0.40 0.03 0.06 0.10 0.028
T7 cached SDI7b 0.97 1.14 1.04 0.33 0.37 0.35 0.079
T11 cached ID11 0.11 0.19 0.28 0.02 0.03 0.04 0.018
|
To Start
MultiThreading Benchmarks
Variations of multithreading benchmarks, produced to run under Linux, have been converted as Android Apps. So far, the C code for multithreading in the Linux benchmarks compiles and works with Android. Links for the benchmarks, results and further details can be found in
www.roylongbottom.org.uk/Android MultiThreading Benchmarks.htm.
The benchmarks are variations of Whetstone, Dhrystone, BusSpeed, RandMem and part of MemSpeed that are reported on above. Results include some for both dual and quad core devices. All run the benchmarks using 1, 2, 4 and 8 threads.
Those that use caches and RAM have data sizes around 12.8 KB, 128 KB and 12.8 MB.
Some of these benchmarks produce poor performance, influenced by Power Saving options and short running time. For versions that run for extended periods see
Android Long MP Benchmarks.htm.
MP-MFLOPS - measures floating point speed on data from caches and RAM.
The arithmetic operations executed are of the form x[i] = (x[i] + a) * b - (x[i] + c) * d + (x[i] + e) * f with 2 and 32 operations per input data word. Data sizes are also limited to three to use L1 cache, L2 cache and RAM at 12.8, 128 and 12800 KB (3200, 32000 and 3200000 single precision floating point words). The program is run using 1, 2, 4 and 8 threads.
MP-Whetstone - Multiple threads each run the eight test functions at the same time, but with some dedicated variables. Measured speed is based on the last thread to finish, with Mutex functions, used to avoid the updating conflict by only allowing one thread at a time to access common data. Again performance is generally proportional to the number of cores used. Floating point speeds and the overall rating, using one thread, are similar to the single CPU version, but integer calculations are slower for some reason.
MP-Dhrystone - This runs multiple copies of the whole program at the same time. Dedicated data arrays are used for each thread but there are numerous other variables that are shared. The latter reduces performance gains via multiple threads (example - 2 threads 1.8 x speed). Single thread results are also slightly slower than the normal benchmark.
MP-BusSpeed - This runs integer read only tests using caches and RAM, each thread accessing the same data sequentially. Performance gains, using L1 cache, can be proportional to the number of cores, but not quite so using L2. The program is designed to produce maximum throughput over buses and demonstrates the fastest RAM speeds using multiple cores.
MP-RandMem - The benchmark has cache and RAM read only and read/write tests using sequential and random access, each thread accessing the same data but starting at different points. It uses the Mutex functions as in Whetstone above. Performance characteristics tend to be constant on a particular system but can be unpredictable, like slower speed using a higher number of threads. On a dual core CPU, there were reasonable gains (1.7x) on serial reading but none elsewhere. A quad core processor showed no gains at all, resulting in certain tests being slower than the dual core system.
To Start
NEON Benchmarks
Some of the benchmarks have been converted to use NEON Single Instruction Multiple Data (SIMD) instructions, using special ARM intrinsic functions. In this case, operating on four 32 bit numbers at the same time. These SIMD instructions are equivalent to Intel SSE and AMD 3DNow instructions. For details and results see
www.roylongbottom.org.uk/Android NEON Benchmarks.htm.
NeonSpeed - This benchmark carries out the same calculations as MemSpeed single precision floating point and integer tests, using caches and RAM. MemSpeed normal calculations are carried out besides the same ones using NEON functions. The latter can be more than three times faster.
NEON MP MFLOPS - This is the same as MP-MFLOPS benchmark above, except, in this case, the operational sequences are generated by NEON Intrinsic Functions.
NEON Linpack - This is the same as the single precision version of the
Linpack 100 Benchmark, described above, except NEON intrisic functions are used for the key calculations.
NEON Linpack MP - This version uses mainly the same C programming code as the single precision floating point NEON compilation above. It is run run on 100x100, 500x500 and 1000x1000 matrices using 0, 1, 2 and 4 separate threads. The 0 thread procedures are identical to above. The initial 100x100 Linpack benchmark is only of use for measuring performance of single processor systems. The one for shared memory multiple processor systems is a 1000x1000 variety. The programming code for this is the same as 100x100, except users are allowed to use their own linear equation solver. Unlike the NEON MP MFLOPS benchmark, that carries out the same multiply/add calculations, this program can run much slower using multiple threads. This is due to the overhead of creating and closing threads too frequently, relative to calculation time.
To Start
Graphics Benchmarks
JavaOpenGL1 -
This benchmark does not rely on complex visual scenes or mathematical functions. The objective being to generate moderate to excessive loading via multiple simple objects. It uses all Java code, with OpenGL ES GL10 statements, to measure graphics performance in Frames Per Second (FPS). Four tests draw a background of 50 cubes first as wireframes then colour shaded. The third test views the cubes in and out of a tunnel with slotted sides and roof, also containing rotating plates. The last test adds textures to the cubes and plates. The 50 cubes are redrawn 15, 30 and 60 times, with randomised positions, colours rotational settings. With 6 x 2 triangles per cube, minimum triangles per frame for the three sets of tests are 9000, 18000 and 36000.
Details and results can be found in
Android Graphics Benchmarks.
To Start
Measure CPU MHz
The app can be downloaded from
www.roylongbottom.org.uk/CPU_MHz.apk.
Source code is in
the zip file. It reads
/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq
This app has Run and Save buttons. Run executes the program for approximately 30 seconds, reporting every second (via sleep(1000) when CPU is not used). Save Emails the results.
A revised version with 100 milliseconds sampling is available via
Android Long MP Benchmarks.htm.
The procedure to use is to load a benchmark then load CPU_MHz, forcing the benchmark into the background. Start the CPU_MHz program, switch the benchmark into foreground and start that. The method for switching apps is not the same on all devices, so you will have to look it up (latest is to press multi-task bottom on-screen button).
Following shows results, measuring MHz whilst running MemSpeed Benchmark, whose results were proportional to MHz.
For comparative benchmarking, running continuously at maximum MHz is desirable.
##################################################
T11 Samsung EXYNOS 5250 2.0 GHz Cortex-A15, Android 4.2.2
Energy Saving Off
MemSpeed Total Elapsed Time 10.9 seconds
Android Java CPU MHz 13-Aug-2013 16:55:50
0.00 1000 1.02 1000
2.08 1000 3.11 1000
4.16 1000 5.18 1000
6.24 1000 7.29 1000
8.32 1700 9.34 1200
10.35 1700 11.36 1700
12.38 1700 13.40 1700
14.42 1700 15.45 1700
16.48 1700 17.50 1700
18.54 1000 19.59 1000
20.64 1000 21.67 1000
22.72 1000 23.76 1000
24.82 1000 25.87 1000
26.93 1000 27.98 1000
29.04 1000 30.08 1000
Running Finished 13-Aug-2013 16:56:22
Energy Saving On
MemSpeed Total Elapsed Time 11.9 seconds
Android Java CPU MHz 14-Aug-2013 11:12:55
0.00 1000 1.02 1000
2.05 1000 3.08 1000
4.11 1000 5.14 1000
6.20 1000 7.23 1000
8.24 1000 9.26 1000
10.28 1000 11.30 1000
12.32 1000 13.34 1000
14.36 1000 15.40 1000
16.43 1000 17.46 1000
18.49 1000 19.52 1000
20.56 1000 21.59 1000
22.62 1000 23.65 200
24.72 1000 25.76 1000
26.80 1000 27.83 1000
28.89 1000 29.92 1000
Running Finished 14-Aug-2013 11:13:26
##################################################
T7 ARM Cortex-A9 1300 MHz, Android 4.1.2
Battery Power
MemSpeed Total Elapsed Time 11.7 seconds
Android Java CPU MHz 14-Aug-2013 09:11:23
0.00 1000 1.03 475
2.06 760 3.09 1300
4.13 1300 5.17 1300
6.31 640 7.34 1200
8.36 1200 9.37 1200
10.39 1200 11.40 1200
12.42 1200 13.43 1200
14.45 1200 15.47 1200
16.49 1200 17.51 1200
18.53 1200 19.57 1000
20.60 760 21.62 1200
22.66 760 23.68 475
24.71 1300 25.74 475
26.78 475 27.82 475
28.85 475 29.89 475
Running Finished 14-Aug-2013 09:11:54
##################################################
T4 ARM Cortex-A9 1500 MHz, Android 4.0.3
CPU Development Performance Setting
MemSpeed Total Elapsed Time 13.0 seconds
Android Java CPU MHz 14-Aug-2013 16:26:27
0.00 1200 1.02 1200
2.04 1200 3.06 1200
4.07 1200 5.09 1200
6.12 1200 7.13 1200
8.15 1200 9.17 1200
10.18 1200 11.20 1200
12.22 1200 13.25 1200
14.27 1200 15.30 1200
16.32 1200 17.34 1200
18.37 1200 19.40 1200
20.44 1200 21.46 1200
22.47 1200 23.49 1200
24.51 1200 25.52 1200
26.54 1200 27.56 1200
28.61 1200 29.63 1200
Running Finished 14-Aug-2013 16:26:58
CPU Development Normal MHz Setting
MemSpeed Total Elapsed Time 13.6 seconds
Android Java CPU MHz 14-Aug-2013 16:21:44
0.01 288 1.08 192
2.16 192 3.25 96
4.42 192 5.66 288
6.71 288 7.84 192
8.93 384 9.97 864
10.99 1200 12.01 1200
13.03 1200 14.05 1200
15.07 1200 16.10 1200
17.12 1200 18.14 1200
19.17 1200 20.20 1200
21.22 1200 22.24 1104
23.26 720 24.29 336
25.34 144 26.46 144
27.57 144 28.69 144
29.81 144 30.92 144
Running Finished 14-Aug-2013 16:22:16
|
To Start
On-Line Benchmarks - Image Loading Times
Three of the tests provided, load and display image files, each of around one million bytes, but producing different numbers of pixels to display. Format of these files are uncompressed BMP, compressed GIF and compressed JPG. A further test loads 400 different GIF icons, each sized approximately 70 Bytes.
These functions, using Java script, are copied from
another HTML file,
for use here, as they have been found to work on Android based devices, but in some strange ways. That HTML document also runs the Whetstone benchmark via Java Applets, but these do not run using Android.
When images are loaded, they can be saved in the browser’s cache on the local device disk. On resubmitting the image page address, or selecting Refresh, the images are likely to be loaded from the cache at high speed. This is generally avoided by loading via a .htm file, renamed as .php, with the time added to the file name, for example using
<img src="gif1m.gif?<? echo time(); ?>">.
Note that the measured time is less than the actual time taken, typically by up to 1.5 seconds, but can be closer on selecting Refresh.
Below are results, based on at least three measurements on the same broadband connection, where maximum speed is normally around 10 Mbps. So, it is likely that minimum loading of the 1 MB files will be greater than one second. For reference, results using Windows and Linux are also provided. These showed that Linux and Firefox was generally faster than Windows with Internet Explorer but Firefox did not help via Windows.
Initial loading times on Android tablet T2 were really slow, using the default browser. Opera, with high speed claims, was installed but only managed to speed up loading times of the small GIF files. T1 tablet, with the older CPU, provided some faster results than PCs with Windows, but failed to display the 1 MB GIF file.
A broadband speed tester confirmed the slow T2 speed at 0.6 Mbps whilst a Linux desktop PC produced 8.5 Mbps.
Loading Time Seconds
MHz OS 1 MB BMP 1 MB GIF 1 MB JPG 400 GIF
Wireless
Tablet T1 ARM 926EJ 800 Android 2.2 2.5-2.8 2.5-2.6# 2.3-2.7 6.5-7.4
Tablet T2 ARM v7-A9 800 Android 2.3.4 13.8-14.4 12.9-14.3 13.4-14.8 11.4-12.3
Tablet T2 ARM v7-A9 800 Andr 2.3.4 OP 13.5-14.3 13.0-14.8 13.2-13.7 5.5-6.0
Tablet T4 ARM v7-A9 1500 Android 4.0.3 2.0-2.3 2.1-2.5 2.0-2.4 3.9-5.2
Netbook Atom 1666 WinXP IE 5.5-5.8 2.5-4.1 2.6-3.2 7.4-8.0*
Netbook Atom 1666 Abuntu FF 1.1-2.3 1.1-2.2 1.2-2.6 4.6-6.6
Laptop Core 2 1833 Win Vista IE 3.3-3.7 3.2-3.4 3.4-3.6 20.7-22.6
Laptop Core 2 1833 Abuntu FF 1.4-2.4 1.3-1.3 1.2-1.8 4.9-5.2
Wired
Desktop 1 Core 2 1600 Abuntu FF 2.2-2.7 1.8-2.9 1.8-1.9 4.6-4.6
Desktop 1 Core 2 2400 Abuntu FF 1.9-2.3 1.1-1.4 1.2-1.4 4.6-4.6
Desktop 2 Phenom 3000 Win 7 IE 2.5-4.3 2.4-3.0 2.4-2.5 4.7-4.8
Desktop 2 Phenom 3000 Win 7 FF 2.4-2.7 2.5-3.0 3.5-2.7 5.3-6.1
Desktop 2 Phenom 3000 Win 7 GC 2.3-2.7 2.5-3.0 2.5-2.6 5.1-6.1
OP = Opera, IE = Internet Explorer, FF = FireFox, GC = Google Chrome
# = no image display, * = stopwatch as timer did not work properly
|
To Start
BlueStacks App Player
BlueStacks is an Android App Player that runs under Windows, downloadable (free October 2012) from
www.bluestacks.com.
The package allocates an icon to any .apk files on a PC. A right click on these gives an option to Open with BlueStacks APP Installer. A download from Internet saves the files on an imaginary SD card and they can be installed from there.
I installed the app on a 64-Bit Windows 7 PC with a 3 GHz quad core Phenom CPU and a 1.83 GHz Core 2 Duo based laptop under 32-Bit Windows Vista. It failed to install via 64-Bit Vista (needed unselectable Administrator approval) and Windows XP (needed something from SP3).
The Systems Used are identified below as BS1 and BS2 and some results are included above. Typically, NDK pre-compiled C/C++ benchmark code, using BlueStacks on a 3 GHz PC, runs at 5% of the speed of Windows versions or 10% of a 1.5 GHz Cortex-A9 tablet CPU. On the other hand, Java benchmarks can run at the same speed as the 1.5 GHz tablet and
much faster speeds can be obtained using RAM sized data - see
BusSpeed Benchmark above.
To Start
Android On PCs
I had a go at installing Android on a PC to run some of my new benchmarks. First attempt was to download the ISO for an Android 4.0 variety, but that did not work. Second was
generic_x86-20120611.iso
(Android 2.2.1, Linux 2.6.35.7). This was burnt to a DVD, tested as live then installed on a USB stick (on a laptop using a Core 2 Duo with hard disk removed). The USB stick booted with Internet accessible via a LAN but WiFi would not connect. Keyboard worked OK, along with mouse left, centre and right button functions. I then found that I could not download my Java Apps. With a bit of luck I found that this was because I had opted to install on the existing drive FAT format, where saving is inhibited.
Next I opted for Ext3 formatting and, before restarting, I found that I could download and run my Java Apps, set up Email and post the results. Then I found that the USB stick would not boot. After several goes at pre-formatting and installing (takes little time), I found that it booted on two desktops (Core 2 DUO and Phenom) and on my Atom based Netbook but not on the Core 2 laptop.
The benchmarks run on these systems were Java Whetstone and Linpack benchmarks, but they are relatively slow, probably due to an inefficient Java Runtime Environment. Details are included above in Java Whetstone Benchmark Results and Java Linpack Results (see And x86).
Using the same programming functions, system information obtained is different running under Android x86. Some details are provided below.
Atom
Android Build Version 2.2.1
bogomips : 3406.65
address sizes : 32 bits physical, 48 bits virtual
processor : 1
vendor_id : GenuineIntel
cpu family : 6
model : 28
model name : Intel(R) Atom(TM) CPU N455 @ 1.66GHz
stepping : 10
cpu MHz : 1667.000
cache size : 512 KB
cpu cores : 1
Linux version 2.6.35.7-android-x86+ (root@afro) (gcc version 4.3.2
(Debian 4.3.2-1.1) ) #1 SMP PREEMPT Sun Feb 20 00:23:02 CET 2011
Core 2 Duo
Android Build Version 2.2.1
bogomips : 4779.78
address sizes : 36 bits physical, 48 bits virtual
processor : 1
vendor_id : GenuineIntel
cpu family : 6
model : 15
model name : Intel(R) Core(TM)2 CPU 6600 @ 2.40GHz
stepping : 6
cpu MHz : 2394.000
cache size : 4096 KB
cpu cores : 2
Linux version 2.6.35.7-android-x86+ (root@afro) (gcc version 4.3.2
(Debian 4.3.2-1.1) ) #1 SMP PREEMPT Sun Feb 20 00:23:02 CET 2011
|
To Start
Systems Used
T1 Device TTFone M013S 10.1 inch tablet, 300-800 MHz VIA 8650
Screen pixels w x h 600 x 1024
Android Build Version 2.2
Processor : ARM926EJ-S rev 5 (v5l)
BogoMIPS : 797.97
Features : swp half thumb fastmult edsp java
CPU part : 0x926
Linux version 2.6.32.9
T2 Device WayTeq xTAB-70 7 inch tablet, 800 MHz Cortex-A9
Screen pixels w x h 600 x 800
Android Build Version 2.3.4
Processor : ARMv7 Processor rev 1 (v7l)
BogoMIPS : 2035.71
Features : swp half thumb fastmult vfp edsp neon vfpv3
CPU part : 0xc09 - Cortex-A9
Linux version 2.6.34
T3 Device Samsung P7500
Screen pixels w x h 1280 x 752
Android Build Version 3.2
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0 BogoMIPS : 1998.84
processor : 1 BogoMIPS : 1998.84
Features : swp half thumb fastmult vfp edsp vfpv3 vfpv3d16
CPU part : 0xc09 - Cortex-A9
Linux version 2.6.36.3
T4 Device Miumiu w17 Pro 7 inch tablet, dual 1500 MHz Cortex-A9
Screen pixels w x h 600 x 976
Android Build Version 4.0.3 - Ice Cream Sandwich
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0 BogoMIPS : 2393.70
processor : 1 BogoMIPS : 2393.70
Features : swp half thumb fastmult vfp edsp neon vfpv3
CPU part : 0xc09 - Cortex-A9
Hardware : Amlogic Meson6 g04 customer platform
Linux version 3.0.8
T5 Device Ainol Novo 7 Paladin Tablet, 1 GHz MIPS CPU, ARM emulation
Screen pixels w x h 480 x 800
Android Build Version 4.0.1
system type : JZ4770
processor : MIPS-compatible processor JZ4770
cpu model : Ingenic Xburst
BogoMIPS : 1005.97
Features : fpu mxu dsp lowpower
CPU implementer : Ingenic
CPU architecture : MIPS
Hardware : npm702
Linux version 2.6.32.9
T6 Device Asus Transformer TF700
Screen pixels w x h 1920 x 1128
Android Build Version 4.0.3
Processor : ARMv7 Processor rev 9 (v7l)
processor : 0 BogoMIPS : 1993.93
processor : 1 BogoMIPS : 1993.93
processor : 2 BogoMIPS : 1993.93
processor : 3 BogoMIPS : 1993.93
Features : swp half thumb fastmult vfp edsp neon vfpv3
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x2
CPU part : 0xc09 - Cortex-A9
CPU revision : 9
Hardware : cardhu - nVidia Tegra 3
Linux version 2.6.39.4
T7 Device Google Nexus 7 quad core CPU 1.3, GHz 1.2 GHz > 1 core
RAM 1 GB DDR3L-1333 Bandwidth 5.3 GB/sec
Screen pixels w x h 1280 x 736 MHz
Twelve-core Nvidia GeForce ULP graphics 416 MHz
Android Build Version 4.1.2
Processor : ARMv7 Processor rev 9 (v7l)
processor : 0 BogoMIPS : 1993.93
processor : 1 BogoMIPS : 1993.93
processor : 2 BogoMIPS : 1993.93
processor : 3 BogoMIPS : 1993.93
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x2
CPU part : 0xc09 - Cortex-A9
CPU revision : 9
Hardware : grouper - nVidia Tegra 3 T30L
Revision : 0000
Linux version 3.1.10
T8 Allwinner A13-MID, 1 GHz ARM Cortex-A8
Internal Drive MB 1007 Free 917
SD Card MB 5455 Free 4575
Screen pixels w x h 800 x 432
Android Build Version 4.0.4
Processor : ARMv7 Processor rev 2 (v7l)
BogoMIPS : 1001.88
Features : swp half thumb fastmult vfp edsp neon vfpv3
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x3
CPU part : 0xc08
CPU revision : 2
Hardware : sun5i
Revision : 0000
Linux version 3.0.8
T9 Device WM8650 800 MHz
Screen pixels w x h 800 x 480
Android Build Version 2.2
Processor : ARM926EJ-S rev 5 (v5l)
BogoMIPS : 797.97
Features : swp half thumb fastmult edsp java
CPU implementer : 0x41
CPU architecture: 5TEJ
CPU variant : 0x0
CPU part : 0x926
Hardware : WMT
Linux version 2.6.32.9
T11 Voyo A15, Samsung EXYNOS 5250 Dual core 2.0 GHz Cortex-A15,
Mali-T604 GPU, 2 GB DDR3-1600 RAM, dual channel, 12.8 GB/s
Screen pixels w x h 1920 x 1032
Android Build Version 4.2.2 - Jelly Bean
Processor : ARMv7 Processor rev 4 (v7l)
processor : 0
BogoMIPS : 992.87
processor : 1
BogoMIPS : 997.78
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls vfpv4
idiva idivt
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x0
CPU part : 0xc0f
CPU revision : 4
Hardware : SMDK5250
Linux version 3.4.35Ut
T12 Samsung GaIaxy Note 2, Quad core 1.6 GHz Cortex-A9
Screen pixels w x h 720 x 1280
Android Build Version 4.1.2
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0 BogoMIPS : 1592.52
processor : 2 BogoMIPS : 2189.72
processor : 3 BogoMIPS : 2189.72
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x3
CPU part : 0xc09
CPU revision : 0
Chip revision : 0020
Hardware : SMDK4x12
Revision : 000b
Linux version 3.0.31
T13 Samsung Galaxy Note 1 Dual Core 1.4 GHz Cortex-A9
Screen pixels w x h 800 x 1280
Android Build Version 4.1.2
Processor : ARMv7 Processor rev 1 (v7l)
processor : 0 BogoMIPS : 1592.52
processor : 1 BogoMIPS : 1990.65
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x2
CPU part : 0xc09
CPU revision : 1
Hardware : SMDK4210
Revision : 0008
Linux version 3.0.31
P1 Device Motorola Milestone 1 CyanogenMod 7 ROM overclocked
Screen pixels w x h 854 x 480
Android Build Version 2.3.5
Processor : ARMv7 Processor rev 3 (v7l)
BogoMIPS : 598.90
Features : swp half thumb fastmult vfp edsp neon vfpv3
CPU part : 0xc08 - Cortex-A8
Linux version 2.6.32.9
P2 Device Samsung Galaxy s
Screen pixels w x h 480 x 800
Android Build Version 2.2
Processor : ARMv7 Processor rev 2 (v7l)
BogoMIPS : 996.00
Features : swp half thumb fastmult vfp edsp neon vfpv3
CPU part : 0xc08 - Cortex-A8
Linux version 2.6.32.9
P3 Device Motorola Milestone 3 (XT860)
Screen pixels w x h 960 x 540
Android Build Version 2.3.6
Processor : ARMv7 Processor rev 2 (v7l)
processor : 0 - CPU 1 of 2
BogoMIPS : 598.90 - too low?
Features : swp half thumb fastmult vfp edsp thumbee neon vfpv3
CPU part : 0xc09 - Cortex-A9
Linux version 2.6.35.7
P4 Device Huawei u8800 - 800 MHz Scorpion CPU - Cortex-A8
Screen pixels w x h 480 x 800
Android Build Version 2.3.5
Processor : ARMv7 Processor rev 1 (v7l)
BogoMIPS : 537.39
Features : swp half thumb fastmult vfp edsp neon vfpv3
CPU part : 0x00f
Hardware : HUAWEI U8800 BOARD
Linux version 2.6.35.7
P5 Device HTC One X - Quad Core
Screen pixels w x h 720 x 1184
Android Build Version 4.0.3
Processor : ARMv7 Processor rev 9 (v7l4
processor : 0 - CPU 1 of 4
BogoMIPS : 1993.93
Features : swp half thumb fastmult vfp edsp neon vfpv3
CPU part : 0xc09 - Cortex-A9
Hardware : endeavoru
Linux version 2.6.39.4
P6 Qualcomm Snapdragon S4, 1500 MHz, 1 GB DDR2 RAM
Device HTC One S Ville - Dual Core
CPU MSM8260A? see P8 HTC One S MSM8960
Screen pixels w x h 540 x 888
Android Build Version 4.0.3
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0
BogoMIPS : 13.53
processor : 1
BogoMIPS : 13.53
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls
CPU implementer : 0x51
CPU architecture: 7
CPU variant : 0x1
CPU part : 0x04d
CPU revision : 0
Hardware : ville
Revision : 0080
Linux version 3.0.8-
P7? Device not given. [Evidence suggests Marvell technology
e.g. Marvell's Brownstone Development Platform and
Marvell - PJ4Bv7 CPU with CPU implementer :0x56,
architecture: 7, CPU part :0x584, rev 2]
Screen pixels w x h 1280 x 752
Android Build Version 4.0.3
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0 BogoMIPS : 831.32
processor : 1 BogoMIPS : 834.00
Features: swp half thumb fastmult vfp edsp iwmmxt thumbee neon vfpv3
CPU implementer : 0x56
CPU architecture: 7
CPU variant : 0x2
CPU part : 0x584
CPU revision : 0
Hardware : Brownstone2x
Revision : 0000
Linux version 3.0.8, (Marvell GCC 201201)
P8 Qualcomm Snapdragon S4, 1500 MHz, 1 GB dual channel RAM
Device HTC One S - Dual Core
CPU MSM8960 see P6 HTC One S MSM8260A?
Screen pixels w x h 540 x 888
Android Build Version 4.0.3
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0
BogoMIPS : 13.53
processor : 1
BogoMIPS : 13.53
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls vfpv4
CPU implementer : 0x51
CPU architecture: 7
CPU variant : 0x1
CPU part : 0x04d
CPU revision : 0
Hardware : QCT MSM8960 CDP
Revision : 0000
Linux version 3.0.8
P9 Device Samsung Galaxy s Captivate
Screen pixels w x h 480 x 800
Android Build Version 2.3.5
Processor : ARMv7 Processor rev 2 (v7l)
BogoMIPS : 996.00
Features : swp half thumb fastmult vfp edsp thumbee neon vfpv3
CPU part : 0xc08 - Cortex-A8
Linux version 2.6.35.7
P10 Qualcomm Snapdragon S4, 1500 MHz, 1 GB dual channel RAM
Device HTC One X - Dual Core
CPU MSM8960
Screen pixels w x h 720 x 1184
Android Build Version 4.0.3
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0
BogoMIPS : 13.53
processor : 1
BogoMIPS : 13.53
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls
CPU implementer : 0x51
CPU architecture: 7
CPU variant : 0x1
CPU part : 0x04d
CPU revision : 0
Hardware : elite
Revision : 0080
Linux version 3.0.8
P11 Samsung Galaxy SIII, Quad Core 1.4 GHz Cortex-A9
Dual Channel DDR2 RAM
Screen pixels w x h 720 x 1280
Android Build Version 4.0.4
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0 BogoMIPS : 1592.52
processor : 1 BogoMIPS : 2786.91
processor : 3 BogoMIPS : 398.13
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x3
CPU part : 0xc09
CPU revision : 0
Hardware : SMDK4x12
Revision : 000c
Serial : 3b065f3d4df1bb2d
Linux version 3.0.15
P13 Samsung Galaxy GT-I9100 SII Dual core 1.2 GHz Cortex-A9
Screen pixels w x h 480 x 800
Android Build Version 4.1.2
Processor : ARMv7 Processor rev 1 (v7l)
processor : 0
BogoMIPS : 1592.52
processor : 1
BogoMIPS : 2388.78
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x2
CPU part : 0xc09
CPU revision : 1
Hardware : SHW-M250K
Revision : 000a
Linux version 3.0.31
P14 Hawaii? Dual Core Cortex-A9
Screen pixels w x h 540 x 888
Android Build Version 4.2.1
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0
BogoMIPS : 2000.48
processor : 1
BogoMIPS : 2000.48
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x3
CPU part : 0xc09
CPU revision : 0
Hardware : hawaii
Revision : 0000
Linux version 3.4.5
P16 LG G2X 512 MB Dual-channel RAM Dual-core Cortex-A9 1 GHz
Screen pixels w x h 480 x 800
Android Build Version 2.3.4
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0 and 1 BogoMIPS : 1998.84
Features : swp half thumb fastmult vfp edsp vfpv3 vfpv3d16
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x1
CPU part : 0xc09
CPU revision : 0
Hardware : Tegra 2 Development System
Linux version 2.6.32
EP1 Device Emulator 3 GHz Phenom
or 2.4 GHz Core 2
Screen pixels w x h 240 x 320
Android Build Version 2.2
Processor : ARM926EJ-S rev 5 (v5l)
BogoMIPS : 522.64
Linux version 2.6.29
ET1 Device Emulator 3 GHz Phenom
Screen pixels w x h 600 x 1024
Android Build Version 2.2
Processor : ARM926EJ-S rev 5 (v5l)
BogoMIPS : 530.84
Linux version 2.6.29
ET2 Device Emulator 3 GHz Phenom
or 2.4 GHz Core 2
Screen pixels w x h 600 x 1024
Android Build Version 4.0.3
Processor : ARMv7 Processor rev 0 (v7l)
BogoMIPS : 527.56
Linux version 2.6.29
BS1 BlueStacks Emulator on 3 GHz Phenom
Screen pixels w x h 1024 x 600
Android Build Version 2.3.4
processor : 0
vendor_id : AuthenticAMD
cpu family : 16
model : 4
model name : AMD Phenom(tm) II X4 945 Processor
stepping : 2
cpu MHz : 3013.000
cache size : 512 KB
-
-
bogomips : 26686.25
Linux version 2.6.38
BS2 BlueStacks Emulator on 1.83 GHz Core 2 Duo
Screen pixels w x h 1024 x 600
Android Build Version 2.3.4
processor : 0
vendor_id : GenuineIntel
cpu family : 6
model : 15
model name : Intel(R) Core(TM)2 Duo CPU T5550 @ 1.83GHz
stepping : 13
cpu MHz : 1828.000
cache size : 2048 KB
-
-
bogomips : 12294.55
Linux version 2.6.38
|
To Start
Roy Longbottom October 2013
The Official Internet Home for my Benchmarks is via the link
Roy Longbottom's PC Benchmark Collection
|